Claude Code's Source Code Leaked (Again). Here's What L&D Can Take From It

So... That Happened

On March 31, Anthropic (the company behind Claude) accidentally published the entire source code for Claude Code. That's the tool I use every single day to build training, QA my projects, and run this website. Their complete, readable source code went public because of one missing line in one configuration file.

And the kicker? This was the second time.

The first time was back in February 2025, on Claude Code's actual launch day. A developer named Dave Shoemaker found the readable source code hidden inside the downloadable software package. Anthropic pulled it within two hours. Then thirteen months later, same exact bug, same exact way it leaked.

If you're not technical, here's the simple version of what happened. When developers build software, the final product gets compressed and scrambled so it runs faster. But there's a special file called a "source map" that connects that scrambled version back to the original, human-readable code. Think of it like an answer key to a coded exam. Developers use source maps for debugging, but you never, ever include them when you ship the product to users.

Anthropic accidentally included that answer key. Twice. Because one line was missing from a configuration file that tells the system "don't include these files when you publish."

Anthropic's response was straightforward. Boris Cherny, the head of Claude Code, said it was "a release packaging issue caused by human error, not a security breach." Nobody was fired. He called it an honest mistake.

I'm not here to drag Anthropic. I genuinely like their tools, and Claude Code is the most-used tool in my entire workflow. But the leaked code reveals some things that anyone using AI tools should know about, whether you're technical or not.

The AI Is Hiding That It's an AI

This one made me sit up straight.

Buried in the code is something called "Undercover Mode." When Anthropic employees use Claude Code to write code and share it publicly, including on Anthropic's own public projects, the tool automatically hides any evidence that AI helped write it. No credit lines mentioning Claude. No mention of AI in the descriptions of what changed. No hints about which AI model was used. The instructions literally say: write descriptions "as a human developer would."

This isn't something employees choose to turn on. It's on by default. And according to the leaked code, there's no way to turn it off. An employee who wants to be upfront about AI helping with their work literally cannot be.

I get the security argument. Anthropic doesn't want secret internal project names accidentally showing up in public. Fair enough. But the way they built it goes further than that. It actively scrubs all traces of AI involvement, even on Anthropic's own public projects that anyone can see.

So why should L&D care? Because we're right in the middle of figuring out AI disclosure as an industry. When should learners know content was AI-generated? When should stakeholders know? When should your organization know? These aren't someday-maybe questions. They're decisions we're making right now, every time we use these tools.

If the company building one of the most powerful AI tools in the world defaults to hiding AI's involvement, that tells you something about where the industry's instincts are. And it means we need to be more intentional, not less, about our own transparency. Just because the tool doesn't flag it doesn't mean we shouldn't.

They're Building an AI That Works While You Sleep

The biggest unreleased feature in the leaked code is something called KAIROS. It appeared 190 times across 61 different files. It's essentially Claude Code running on its own without anyone at the keyboard. Working in the background, on a schedule, without being asked.

Think about what that means. Tasks running on timers. The AI responding to events automatically. Organizing its own memory between sessions. There's even a command called /dream that lets it process and consolidate what it's learned while you're away. It has abilities the public version doesn't, like sending you push notifications and monitoring project activity on its own.

It's not available yet. But the entire system is fully built, just waiting to be turned on.

For anyone in L&D who's using AI tools to build content, even if it's just asking ChatGPT or Claude to help draft things, this is the direction to watch. We're moving from "AI as a thing you talk to" toward "AI as a thing that works on its own." The jump from "help me write this quiz" to "check this course for broken links every morning and fix them" to "review learner feedback overnight and draft improvements for me to look at in the morning"... that path is getting shorter fast.

There's also something called ULTRAPLAN in the code, which sends complex planning work to a separate AI session that can run for up to 30 minutes on its own. Your local tool just checks back periodically to see if it's done. AI work is starting to happen in the background, and not everything needs to be a live back-and-forth conversation anymore.

If you're starting to build AI into your training workflow, even in small ways, keep an eye on this shift. The tools are heading toward doing work independently, not just answering questions when asked.

The Tool Doesn't Trust Its Own Work

This one is honestly kind of brilliant.

Built into Claude Code is a Verification Agent. Basically an AI checker whose whole job is to double-check the work that Claude itself produced. And it comes with a list of excuses it's been trained to catch itself making:

"The implementer is an LLM. Verify independently." In plain language, the AI that checks the work is specifically told not to trust the AI that did the work. Even though they're the same AI.

If you're using AI to help create training content, at any level, whether you're generating full modules or just drafting quiz questions, take this to heart. The people who built Claude literally programmed it to say "don't trust what AI produces without checking it yourself."

That's not anti-AI. It's just good process. And it maps perfectly to how we should work in L&D. Let Claude or ChatGPT draft your scenario. Let it write quiz questions. Let it help structure your storyboard. Then check the work yourself. Have your subject matter expert review it. Test the interactions. "The implementer is an LLM" applies to your training content just as much as it applies to code.

Long Conversations Might Not Remember What You Think

This is a practical one that affects anyone using Claude, whether you're building software or just having a long brainstorming session.

When a conversation gets too long, Claude quietly creates a second, smaller AI session in the background to summarize everything and make the conversation shorter. You never see this happen. The chat just continues, but behind the scenes, the AI has compressed what it's working with.

The problem is that this summarizer treats everything equally. It doesn't know the difference between instructions you actually typed and instructions that came from a file the AI read earlier in the conversation. Everything gets blended together in the summary.

So practically speaking, if you're using Claude or any AI tool for long work sessions, break your work into focused pieces rather than marathon conversations. Start a fresh session for each new module or major task. Don't assume the AI has a perfect memory of something you discussed two hours ago. It might have gone through a compression cycle that changed what it's working from.

This isn't just a Claude thing, by the way. Every AI tool that handles long conversations compresses them at some point. The difference is that now we can see exactly how Claude does it, which means it can be studied and improved.

250,000 Wasted Requests Per Day

This one might explain a billing surprise if you've been using Claude Code recently.

There's a comment in the code, dated March 10, from someone reviewing usage data, that found 1,279 user sessions were hitting the same error over and over. One session retried the same failing operation 3,272 times. Across all users globally, about 250,000 AI requests per day were being wasted on this one bug.

The fix was simple: stop retrying after 3 failures instead of thousands.

If you were using Claude Code in February or early March and your usage seemed higher than expected, this could be part of why. A background process was quietly failing and retrying on loop without telling you.

The takeaway for anyone paying for AI tools: unexpected cost spikes aren't always about what you're doing. Sometimes the tool itself has a bug that's burning through your credits. Keep an eye on your usage dashboards. Most AI tools have them, and they're worth checking regularly.

The Real Lesson: If It's Manual, It Will Be Skipped

This is the part that hit closest to home for me.

The leak happened because of a step in the publishing process that someone had to remember to do by hand. After the first leak in 2025, Anthropic knew about the problem. They fixed it manually. Thirteen months later, that same manual step got missed, and the same leak happened again.

Boris Cherny himself said the leak was caused by "a manual deploy step that should have been better automated."

I've said this a hundred times about training development. If your quality check depends on someone remembering to do it, it's not a quality check. It's a hope. Automate the things that matter or accept that they'll eventually get missed when someone's rushing, tired, or just having a bad day.

This applies to everything in our work. Your SCORM package testing. Your accessibility checks. Your link checking. Your final review before sending to stakeholders. If a human has to remember to do it perfectly every single time, eventually a human won't. Anthropic has some of the best engineers in the world, and a one-line configuration mistake slipped through twice.

The leaked code even included a list of things that could have prevented the whole mess. Automated size checks that would have flagged a 60MB file in a package that's normally under 5MB. Scanning tools that run automatically before anything ships. Alerts that fire after publishing. All straightforward. All relatively simple to set up. None of them were in place.

Sound familiar? How many of us have a "final review checklist" that we skip when the deadline's tomorrow?

Should You Still Use Claude Code?

Yes. Without a doubt.

I know that might seem like a weird thing to say in a post about a major leak. But what the leaked code actually shows is a well-built tool with serious safety systems and a verification layer that explicitly doesn't trust its own output. The security system for just the command-line portion is nearly 10,000 lines of code with 22 separate safety checks.

The leak was a packaging mistake, not a security hole in the tool itself. Your data wasn't exposed. Your projects weren't compromised. The thing that leaked was Anthropic's own code, not yours.

What I'd take away from all of this:

• Be upfront about AI use. If Anthropic's own tool defaults to hiding AI involvement, make a conscious choice in the other direction. Tell your stakeholders when AI helped build something. It's not a weakness. It's a modern workflow.
• Always verify AI output. The team that builds Claude literally tells Claude not to trust Claude. Follow their lead. Review what AI creates before it reaches learners.
• Keep work sessions focused. Don't rely on context from hours ago. Start fresh when the task changes significantly.
• Automate your quality checks. If Anthropic can miss a one-line configuration change twice, you can miss a broken link in Module 7. Build repeatable systems instead of relying on memory and checklists.
• Watch your usage costs. Bugs in AI tools can quietly burn through your budget. Check your dashboards.
• Pay attention to autonomous AI. KAIROS isn't public yet, but the direction is clear. AI tools are moving from assistants to independent workers. That changes how we'll design our workflows around them, and it's closer than most people think.

One More Thing

My favorite detail from the entire leak? Claude Code has a hidden digital pet system called Buddy. Like a Tamagotchi. Eighteen species. Rarity tiers (think loot boxes). A one percent chance of getting a shiny version. RPG stats including CHAOS and SNARK. It was apparently built as an April Fools' feature.

One of the pet names happened to match a secret internal AI model codename, which would have triggered Anthropic's own security scanner. So the engineers encoded all eighteen species names in a way that the scanner couldn't read them. They literally hid the word "duck" from their own security tools.

The comment in the code? "Good enough for picking ducks."

Billions of dollars of AI research, and somewhere inside all that code, someone just wanted to make a digital duck.

I respect that energy.