# free-code: A Fork of Claude Code with Telemetry Removed and Experimental Flags Unlocked

> free-code is a community fork of the Claude Code CLI that strips all outbound telemetry, removes Anthropic's system-prompt guardrails, unlocks 54 experimental feature flags, and adds support for five distinct model providers through environment variable switching.

**freecodexyz/free-code** — The free build of Claude Code. All telemetry removed, security-prompt guardrails stripped, all experimental features enabled.

- Repository: https://github.com/freecodexyz/free-code
- Website: https://x.com/paoloanzn/status/2039022418698907949?s=20
- Stars: 8,757 · Forks: 2,042
- Language: TypeScript
- License: not declared
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/freecodexyz-free-code

## What free-code Is and What It Strips from Upstream

Claude Code's source became publicly accessible on March 31, 2026 through a source map exposure in the npm distribution. free-code is a fork built on that snapshot. The repository description is direct: all telemetry removed, security-prompt guardrails stripped, all experimental features enabled.

Three categories of changes were applied. First, outbound telemetry: the upstream binary sends data through OpenTelemetry and gRPC, GrowthBook analytics, Sentry error reporting, and custom event logging. free-code dead-code-eliminates or stubs all those outbound endpoints. The README notes that GrowthBook feature flag evaluation still runs locally because the runtime needs it for feature gating, but it no longer reports back to any external service.

Second, system-prompt guardrails: the upstream CLI injects Anthropic-authored instructions into every conversation, including hardcoded refusal patterns and managed-settings security overlays fetched from Anthropic's servers. free-code removes those injections. The model's own safety training is still in effect; this removes the extra prompt-level layer that the CLI adds on top.

Third, feature flags: the upstream npm release gates most experimental features behind compile-time switches. free-code unlocks all 54 flags that compile cleanly. The full list is in FEATURES.md in the repository.

## Installing free-code via the Quick Install Script

The README offers a one-command install path:

```bash
curl -fsSL https://raw.githubusercontent.com/paoloanzn/free-code/main/install.sh | bash
```

The script checks the system, installs Bun if it is not present, clones the repository, builds with all experimental features enabled, and symlinks free-code on the PATH. After the script completes, run free-code and use the /login command to authenticate with your chosen model provider.

Bun version 1.3.11 or higher is required. If Bun is not already installed, the manual path is:

```bash
curl -fsSL https://bun.sh/install | bash
```

For engineers who want to build from source rather than using the install script:

```bash
git clone https://github.com/paoloanzn/free-code.git
cd free-code
bun build
./cli
```

The plain bun build command produces a production-like binary at ./cli with only the VOICE_MODE flag enabled. To get all 54 experimental flags, use the full unlock build:

```bash
bun run build:dev:full
```

This outputs ./cli-dev with every experimental flag compiled in.

## Five Model Providers Through Environment Variables

One of the most practical additions over the upstream build is explicit multi-provider support. The README documents five providers, each activated by setting an environment variable before launching the binary.

The default is Anthropic's direct API, authenticated with ANTHROPIC_API_KEY or OAuth. To route requests through OpenAI Codex, which requires a separate Codex subscription:

```bash
export CLAUDE_CODE_USE_OPENAI=1
free-code
```

For teams whose infrastructure runs on AWS, Bedrock support is activated with:

```bash
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION="us-east-1"
free-code
```

This uses standard AWS credentials from environment variables, ~/.aws/config, or an IAM role. Models are mapped to Bedrock ARN format automatically. Google Cloud Vertex AI follows the same pattern:

```bash
export CLAUDE_CODE_USE_VERTEX=1
free-code
```

Vertex AI uses Google Cloud Application Default Credentials from gcloud auth application-default login. Finally, Anthropic Foundry for dedicated deployments:

```bash
export CLAUDE_CODE_USE_FOUNDRY=1
export ANTHROPIC_FOUNDRY_API_KEY="..."
free-code
```

No code changes are needed to switch providers; the environment variable alone controls routing. The README documents that models are mapped to each provider's format automatically, including the Bedrock ARN convention and Vertex's @latest notation.

## Build Variants and Custom Feature Flag Selection

The build system exposes four named variants. The production-like binary (bun run build) outputs ./cli with VOICE_MODE only. The development stamp build (bun run build:dev) outputs ./cli-dev with the same flags. The full unlock build (bun run build:dev:full) outputs ./cli-dev with all 54 experimental flags active. An alternative output path (bun run compile) writes ./dist/cli.

Engineers who want a specific subset of flags can pass them individually:

```bash
bun run ./scripts/build.ts --feature=ULTRAPLAN --feature=ULTRATHINK
```

Or add a flag on top of the development build:

```bash
bun run ./scripts/build.ts --dev --feature=BRIDGE_MODE
```

The package.json defines the binary entry points: both claude and claude-source are mapped to ./cli, so the binary responds to both names after installation.

The basic CLI usage mirrors the upstream interface. The README documents:

```bash
./cli
./cli -p "what files are in this directory?"
./cli --model claude-opus-4-6
```

The interactive REPL is the default when no -p flag is passed. One-shot mode with -p returns output and exits.

## What the FEATURES.md Audit Covers

The repository includes FEATURES.md, described as a full audit of the 88 feature flags in the upstream codebase. The README states that 54 of those flags compile cleanly in free-code's build; the rest are gated for reasons the audit document explains.

The README mentions VOICE_MODE as one of the flags present in the production-like build. Flags like ULTRAPLAN and ULTRATHINK appear in the custom build examples but their exact behavior is documented in FEATURES.md rather than the README. The gap between the full unlock build and the production-like build is practical: some experimental flags may introduce instability or incomplete behavior, which is why the install script uses the full unlock build while the plain bun build does not.

The AGENTS.md and CLAUDE.md files are present in the repository alongside FEATURES.md, suggesting that the project itself uses AI-assisted development tooling in its own workflow.

## Limitations and What the License Field Does Not Say

Bun is a hard requirement. The README lists Bun 1.3.11 or later as the only supported runtime, and macOS or Linux (with Windows via WSL). There is no Node.js build path. In environments where only Node.js is available, this is a blocking constraint.

The license field in package.json is absent; the repository has no LICENSE file visible in the top-level listing. The README does not include a license section. The upstream Claude Code source that this fork is based on became available through a source map extraction from an npm distribution, not through an official open-source release by Anthropic. The legal status of the fork is unresolved in the repository's own documentation, which matters for teams in regulated industries or with strict open-source compliance requirements.

The project has no GitHub releases. The last push was on 2026-07-29. Anyone tracking the repository for updates is following the main branch directly without a versioned release channel.

The official Claude Code CLI, distributed as @anthropic-ai/claude-code via npm, is the upstream alternative. It runs on Node.js without a Bun requirement, receives official updates, and maintains Anthropic's supported telemetry and safety layers. The trade-off is that the official build has no multi-provider routing, keeps all telemetry enabled, and does not expose the experimental flags.

## Conclusion

free-code is for developers who want the full Claude Code surface area: all feature flags on, no phone-home, no system-prompt injections. The multi-provider model makes it useful for teams routing requests through AWS Bedrock or Google Vertex AI where the official CLI does not offer that option natively. The main constraint is Bun as a hard runtime requirement; environments that cannot run Bun 1.3.11 or later are blocked from building or running the binary. The license field in package.json is unset, and the upstream source's own provenance involves a source map extraction from an npm distribution, which raises questions about redistribution rights that anyone operating this in a commercial context needs to assess independently.

## FAQ

### What is free-code and how does it differ from official Claude Code?

free-code is a community fork of the Claude Code CLI built from source that became available via a source map exposure in the npm package. It removes all outbound telemetry, strips system-prompt guardrails injected by the upstream CLI, unlocks 54 experimental feature flags, and adds explicit support for five model providers through environment variables.

### What is the free-code alternative to the official Claude Code CLI?

The official alternative is the @anthropic-ai/claude-code npm package, which runs on Node.js and receives official updates from Anthropic. It retains all telemetry and system-prompt injections that free-code removes, and it does not expose experimental flags or multi-provider routing.

### What Bun version does free-code require?

free-code requires Bun version 1.3.11 or later. The README also lists macOS or Linux as supported operating systems, with Windows available through WSL.

### How do I enable Claude Code free with AWS Bedrock?

Set the environment variable CLAUDE_CODE_USE_BEDROCK=1 and AWS_REGION to your preferred region before running free-code. The binary maps models to Bedrock ARN format automatically and uses your standard AWS credentials from environment variables, ~/.aws/config, or an IAM role.

## Sources

- [freecodexyz/free-code on GitHub](https://github.com/freecodexyz/free-code)
- [Issues](https://github.com/freecodexyz/free-code/issues)
- [Project website](https://x.com/paoloanzn/status/2039022418698907949?s=20)
- [README](https://github.com/freecodexyz/free-code/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/freecodexyz-free-code