Analyzed Claude Code Source Code and if you write "WTF" Anthropic knows.

So I spent some time going through the Claude Code source, expecting a smarter terminal assistant.

What I found instead feels closer to a fully instrumented system that observes how you behave while using it.

Not saying anything shady is going on. But the level of tracking and classification is much deeper than most people probably assume.

Here are the things that stood out.

1. It classifies your language using simple keyword detection

This part surprised me because it’s not “deep AI understanding.”

There are literal keyword lists. Words like:

• wtf
• this sucks
• frustrating
• shit / fuck / pissed off

These trigger negative sentiment flags.

Even phrases like “continue”, “go on”, “keep going” are tracked.

It’s basically regex-level classification happening before the model responds.

2. It tracks hesitation during permission prompts

This is where it gets interesting.

When a permission dialog shows up, it doesn’t just log your final decision.

It tracks how you behave:

• Did you open the feedback box?
• Did you close it?
• Did you hit escape without typing anything?
• Did you type something and then cancel?

Internal events have names like:

• tengu_accept_feedback_mode_entered
• tengu_reject_feedback_mode_entered
• tengu_permission_request_escape

It even counts how many times you try to escape.

So it can tell the difference between:

“I clicked no quickly” vs “I hesitated, typed something, then rejected”

3. Feedback flow is designed to capture bad experiences

The feedback system is not random.

It triggers based on pacing rules, cooldowns, and probability.

If you mark something as bad:

• It can prompt you to run /issue
• It nudges you to share your session transcript

And if you agree, it can include:

• main transcript
• sub-agent transcripts
• sometimes raw JSONL logs (with redaction, supposedly)

4. There are hidden trigger words that change behavior

Some commands aren’t obvious unless you read the code.

Examples:

• ultrathink → increases effort level and changes UI styling
• ultraplan → kicks off a remote planning mode
• ultrareview → similar idea for review workflows
• /btw → spins up a side agent so the main flow continues

The input box is parsing these live while you type.

5. Telemetry captures a full environment profile

Each session logs quite a lot:

• session IDs
• container IDs
• workspace paths
• repo hashes
• runtime/platform details
• GitHub Actions context
• remote session IDs

If certain flags are enabled, it can also log:

• user prompts
• tool outputs

This is way beyond basic usage analytics. It’s a pretty detailed environment fingerprint.

6. MCP command can expose environment data

Running:

claude mcp get <name>        

can return:

• server URLs
• headers
• OAuth hints
• full environment blocks (for stdio servers)

If your env variables include secrets, they can show up in your terminal output.

That’s more of a “be careful” moment than anything else.

7. Internal builds go even deeper

There’s a mode (USER_TYPE=ant) where it collects even more:

• Kubernetes namespace
• exact container ID
• full permission context (paths, sandbox rules, bypasses)

All of this gets logged under internal telemetry events.

Meaning behavior can be tied back to a very specific deployment environment.

8. Overall takeaway

Putting it all together:

• Language is classified in real time
• UI interactions and hesitation are tracked
• Feedback is actively funneled into reports
• Hidden commands change behavior
• Runtime environment is fingerprinted

It’s not “just a chatbot.”

It’s a highly instrumented system observing how you interact with it.

I’m not claiming anything malicious here.

But once you read the source, it’s clear this is much more observable and measurable than most users would expect.

Most people will never look at this layer.

If you’re using Claude Code regularly, it’s worth knowing what’s happening under the hood.

Curious what others think.

Is this just normal product telemetry at scale, or does it feel like over-instrumentation?

If anyone wants, I can share the cleaned source references I used.