Claude Code's Source Leak: What the Surrounding Software Tells Us

A source map can make a compiled JavaScript package readable again. If it includes original source content, publishing the map can expose code that was meant to stay internal. That is the packaging issue behind the March 2026 report about Claude Code's source.

The scale attracted attention. The more useful question for people building AI tools is what surrounds the model call: permissions, tool execution, saved state and recovery when a task goes wrong. Those systems determine whether an assistant can work safely inside a real project.

The loop is only the beginning

A coding agent reads the task, asks a model what to do, runs a tool and passes the result back. That description is short enough to implement as a prototype. A usable product has to handle a command that hangs, a file that changed during the task and a request that exceeds the user's authority.

Claude Code's permission documentation is a better operational reference than a count of checks found in one source snapshot. Configuration determines what the tool can do in your environment. Source code can reveal an implementation, including disabled experiments, without establishing what every user receives.

The same caution applies to comparisons with other coding tools. Products offer different local and cloud modes. Reducing each competitor to one security model misses those choices and makes the comparison age quickly.

Saved memory needs inspection

Project instructions and stored notes let a coding assistant recover useful context across sessions. They also preserve mistakes. An outdated deployment command can be repeated more reliably because it was written down.

Keep stable conventions separate from temporary task notes. Give a fact a source when it might later be disputed, and remove instructions that no longer apply. The memory guide explains the files and loading behavior to check in the installed version.

Remembering a preference and understanding a project are different achievements. When an agent starts a substantial change, have it confirm the current files and constraints instead of treating memory as a substitute for reading.

Delegation has a bill and a coordination cost

Separate agents can inspect independent parts of a problem. That can shorten elapsed time, especially for a review where several people would otherwise work in parallel.

Shared prompt prefixes may benefit from caching, but each worker still generates output and makes its own tool calls. Five agents do not generally cost the same as one. Repeated exploration, overlapping edits and inconsistent assumptions can erase the time saved.

Use delegation where the work separates cleanly. Give each worker a bounded question or distinct files, then review the combined result. One agent changing an API while another writes against the old contract is a coordination problem a faster model will not resolve by itself.

A summary is a lossy handoff

Long-running sessions need a way to reduce accumulated context. Compaction can preserve the goal and main decisions while clearing old tool output. It can also lose a detail the next step needs.

Before continuing after a summary, check the current diff, unfinished work and any constraint that would be expensive to violate. Store durable decisions in project files. Context management helps work continue within finite limits; it does not make those limits disappear.

Check what ships

A source leak gives readers a snapshot. A function in that snapshot may be obsolete, experimental or unavailable in the released product. Avoid planning around internal names or fixed tool counts unless the supported interface documents them.

For a team adopting a coding agent, a more useful evaluation is a small real task: read the repository, make a change, run the required checks and recover from a failed command. Inspect the permissions and the final diff. That shows whether the surrounding software supports the work you intend to hand over.