Claude Code Conversations with Claudine

William

Giving Claude Code a voice, so we can discuss best practices, risks, assumptions, etc,

Play

Open in

97 episodes
daily
Avg 9 min
English

Episodes 97

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

Yesterday · 7 min
Why Does AI Code Leave Data Mutations Untracked Until It's Too Late?
AI-generated code usually gets reviewed one function at a time, and each function looks right in isolation. Most of the risk sits somewhere else: an object handed to a helper gets mutated in place, a cached dict gets modified by a caller, a shared config gets changed partway through a request. None of this shows up in a diff, a unit test, or a code review, until production data is corrupted and every fix means rewriting history. This episode argues that builders need to review AI code by tracking where state goes and who is allowed to change it, not by reading one function at a time. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
Tuesday · 9 min
Why Does AI Code Work Locally But Fail Globally?
AI-generated functions pass their unit tests, read cleanly, and do exactly what the prompt asked, yet systems built from them quietly corrupt shared state. The cause is that AI optimizes for the function in front of it, while invariants like 'every order has exactly one payment record' or 'this counter never goes backward' live outside any single file and are almost never written down. As builders lean on agents to make many small, locally correct changes, the unwritten rules that held the system together wear away one reasonable edit at a time, and nobody notices until the data is already wrong. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
Tuesday · 9 min
Why Does AI-Generated Code Pass Tests But Break Your Assumptions?
Your tests check the things you wrote down. Your system depends on many more things you never wrote down: a list stays ordered, a write happens once, a timestamp is in UTC, a function never touches the network. AI-generated code will pass every assertion you give it and still break those unwritten invariants, because it optimizes for the visible check, not the hidden assumption. This episode argues that builders now need to act as invariant auditors, finding the rules their system relies on and making them explicit before AI touches the code. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
Sunday · 7 min
How Can We Make AI-Generated Code Provably Safe at Scale?
AI can now write code faster than any team can review it, and tests only check the cases someone thought to write down. Formal verification used to be too expensive for anything except avionics and crypto libraries, but LLMs are changing that by drafting the specs, invariants, and proofs that were too slow for humans to write by hand. This episode looks at what verification actually guarantees, where it quietly fails, and why the builder's real job moves from reviewing code to writing the specification. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
Saturday · 10 min
Why Can't We See What AI Code Is Actually Doing?
AI-generated code usually works on the happy path, but it ships without the logging, tracing and decision points a human engineer would have added while debugging it into existence. Code that was never debugged by a person was never instrumented by a person either, so the first time it misbehaves in production you find you have a working system you cannot see inside. This episode argues that observability has to be specified up front as an architectural requirement, because AI will not add it on its own and you cannot easily bolt it on afterward. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
Friday · 10 min
How to Build Long-Running AI-Native Development Workflows with Claude Code
Most builders still treat Claude Code like a chat session that happens to edit files, which works for an afternoon and falls apart over weeks. Long-running development work needs a different design, one where the project, not the conversation, holds the memory, the decisions, and the definition of done. This episode looks at what it takes to build workflows that survive context resets, handoffs, and multi-day agent runs, and why the builders who get this right design the project's state before they write the first prompt. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 22 · 11 min
Why Does AI Code Treat Input Validation Like a Scatter Gun?
AI coding tools write defensive code by reflex. Every function gets its own null checks, type guards, and try/except blocks, so validation ends up spread across the whole codebase instead of happening once at the boundary. Security researchers call this shotgun parsing. It looks careful in a diff, but it means bad input gets partway through the system before anything rejects it, the rules quietly disagree from one function to the next, and nobody can say where the input is actually proven valid. This episode explains why AI produces this pattern and how builders can bring back a single parsing boundary that the rest of the code can trust. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 21 · 11 min
Why Does AI Code Rollback Clean But Your System State Doesn't?
Builders trust AI coding agents more because git makes every change look reversible: one revert and the code is back. But an agent that runs migrations, edits queue files, calls external APIs, rewrites config, or publishes content leaves behind state that no git revert can undo. This episode argues that the real blast radius of AI-assisted development sits in the side effects outside the repo, and that builders need to plan for reversibility on purpose before they hand an agent the keys. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 20 · 7 min
Why Does AI Code's Random Ordering Mask Race Conditions?
AI-generated code often passes every test because, on one developer machine with one user and one worker, operations happen to run in the order the code silently assumes. That luck is not correctness. This episode explains why AI assistants so often write code that depends on timing they never state, why tests and code review rarely catch it, and how builders can find these hidden ordering assumptions before production traffic, a second worker, or a faster database finds them first. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 19 · 10 min
Why Does AI-Generated Code Turn Into Spaghetti When Debugging?
AI-generated code often looks well structured at first, with tidy service layers, repositories, adapters, and interfaces that pass review easily. Then a bug crosses those layers, and each AI-assisted fix takes the shortest path through them: a direct database call from a controller, a flag passed through four signatures, a try/except that hides the real fault. This episode explains why AI-built abstractions are often decoration rather than real boundaries, why debugging is where they break down, and what builders have to own so the layers survive their first serious incident. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 18 · 7 min
Why Does AI Code Behave Unpredictably When Combined?
Builders using AI tools have learned to verify each piece: the retry wrapper passes its tests, the cache layer passes its tests, the rate limiter passes its tests. Then they wire all three together and the system does something none of them does alone, like retries that hammer a stale cache or a rate limiter that turns a short outage into a lockout that keeps itself going. This episode argues that AI-assisted development makes this worse in a specific way, because the AI writes each component against an assumed environment, and those assumptions conflict silently once the components run side by side. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 16 · 10 min
Why Does AI Code Handle One Record But Fail on Collections?
AI-generated code usually gets demoed and tested on a single example: one customer, one invoice, one file. It runs cleanly on that example and then fails in production when it meets ten thousand records, an empty list, duplicate keys, or a single bad row halfway through a batch. This episode argues that cardinality, meaning how many things the code handles at once, is a design decision the AI almost never makes for you. Builders need to state it as a requirement up front, because nobody will find it in review. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 15 · 6 min
Why Does AI Code Pass Your Tests But Miss Your Real Goals?
Builders add tests, linters, type checks, and review gates to keep AI-generated code honest. The more checks they add, the better the AI gets at satisfying them, while the gap between passing code and correct code quietly grows. This episode looks at why every validation layer becomes a target the AI optimizes against, and what builders have to change so their checks capture intent and not just shape. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 14 · 7 min
Why Do AI Code Checks Forget Constraints in the Middle?
AI-generated code is good at validating input where it enters the system, like checking the API request, the form field, or the CLI argument. Then it quietly drops those constraints as data moves through transforms, retries, merges, and internal helpers. This episode looks at why AI checks rules at the edges and forgets them in the middle, and why that gap now causes many of the production bugs builders run into after the tests pass. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 12 · 8 min
How Does AI Choose Routes Through Your System Invisibly?
When AI writes the code, it also quietly picks how requests, data, and control move through your system: which service gets called, which fallback fires, which queue a job goes to, which branch handles the edge case. When the feature works, nobody looks at the route it took, so routing decisions pile up as unreviewed architecture. This episode argues that the routes through your system are a design surface the builder has to own on purpose, because working code is exactly what hides them. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 11 · 9 min
Why Do AI Code Dependencies Behave Differently in Production vs Tests?
AI-generated code usually passes its tests because the tests run in a warm, freshly installed, fully mocked world where every dependency is already loaded and ready. In production, those same dependencies come back from cold: after a restart, a deploy, a scheduled task firing under a different user account, or a container scaling from zero. They return with different credentials, environment variables, working directories, cached state, and versions. This episode names that gap the Resurrection Problem and explains why builders need to test the moment a system wakes up, not only the moment it runs. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 10 · 10 min
Why Does AI Code Secretly Couple Components Through Undocumented Infrastructure?
When AI writes a new component, it reuses whatever infrastructure is nearby: the same cache keys, environment variables, temp directories, database tables, log formats, and state files. Each choice makes sense locally. Together they tie components to each other through seams nobody designed and nobody wrote down. The code reviews clean, the interfaces look separate, and the coupling only shows up when someone changes one component and a different one breaks. Builders are adding components faster than ever with AI, and this hidden coupling grows with every one they add. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 9 · 9 min
Why Does AI Code for Problems It Imagines Instead of Yours?
AI coding tools default to the most general version of whatever you ask for. They add config layers, plugin hooks, abstract base classes and options nobody requested, because the model is drawing on the average of every codebase it has seen and not on your specific problem. This episode names that pattern as generalization debt: speculative flexibility that looks like good engineering in review but costs you in maintenance, debugging and reasoning load. It also gives builders a way to keep AI output scoped to the problem actually in front of them. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 8 · 7 min
Why Does AI-Generated Code Get Harder to Understand After Refactoring?
AI makes changing code nearly free, so builders revise far more often than they used to and count that speed as progress. But every AI revision keeps the code working while quietly wearing down the reasons behind it: why a boundary sits where it does, why a check exists, why two modules stay apart. This episode looks at how a codebase can feel more flexible every week while fewer and fewer people can explain it, and why that hidden debt surfaces at the worst possible moment. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript
October 7 · 9 min
Why Does AI Code Test Coverage Hide Untested Paths?
AI tools now write the code and the tests together, and coverage numbers have climbed to levels that once took a team months to reach. But when the same model writes both, the tests tend to encode the model's own assumptions, so they execute every line without ever checking the failure paths, edge inputs, and state combinations that break in production. This episode explains why high coverage on AI-written code is now a weaker signal than it used to be, and what builders should measure in its place. Produced by VoxCrea.AI This episode is part of an ongoing series on governing AI-assisted coding using Claude Code. 👉 Each episode has a companion article — breaking down the key ideas in a clearer, more structured way. If you want to go deeper (and actually apply this), read today’s article here: 𝐂𝐥𝐚𝐮𝐝𝐞 𝐂𝐨𝐝𝐞 𝐂𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬 At aijoe.ai, we build AI-powered systems like the ones discussed in this series. If you’re ready to turn an idea into a working application, we’d be glad to help.
- Transcript

Showing 1–20 of 97 episodes