Free-Code – Experimental Claude Code CLI

free-code

Visual Introduction and Context

The opening visual presents a compact, command-line oriented ecosystem branded as “free-code,” a free build of Claude Code. The layout suggests a CLI-first project that emphasizes a streamlined workflow with minimal telemetry and maximal experimental capabilities.
The header line proclaims, in bold, “The free build of Claude Code,” followed by a succinct value proposition: “All telemetry stripped. All guardrails removed. All experimental features unlocked. One binary, zero callbacks home.” This sets the expectation of an unrestrained development tool aimed at developers who want control, transparency, and raw access to features.
A row of badges sits under the banner, signaling quick access to installation, community activity, and feature visibility. The badges, visually reminiscent of GitHub readme widgets, imply a project that is both accessible (install/install-a-line) and feature-rich (feature flags, IPFS mirror). This combination suggests a tool that is meant to be experimented with, extended, and integrated into a developer’s existing toolchain.
The overall tone and composition hint at a hybrid between a conventional CLI utility and a research-oriented project. It projects a sense of openness—an experimental build you can clone, tailor, and run with your preferred model providers.

Quick Install: Streamlined Onboarding for Exploration

The Quick Install section offers a one-liner approach to provisioning a fully functional environment. The core idea is to minimize friction so developers can start evaluating features immediately.
Step-by-step flow (summary):
A single curl command fetches an install script from a GitHub raw URL and executes it via bash.
The installer checks the host system requirements, ensures Bun (a modern JavaScript runtime) is available, and installs it if missing.
The script then clones the free-code repository, runs a full build with experimental features activated, and symlinks the free-code binary to the PATH for convenient access.
Post-installation, running free-code and invoking the /login command allows authentication with a preferred model provider.
The emphasis is on automation and reproducibility: a developer can reproduce a clean, feature-rich environment with a single command sequence, making it ideal for quick experiments, demos, or CI-like setups in local environments.
The Quick Install approach also signals a commitment to cross-environment operability, as Bun is chosen for its performance and compatibility across macOS and Linux, with an acknowledgement that Windows users can operate via WSL.

What Is Free-Code: Core Identity and Rationale

Free-Code is positioned as a clean, buildable fork of Anthropic’s Claude Code CLI, reframed as a terminal-native AI coding assistant. The idea is to preserve the core capabilities of Claude Code while offering bespoke alterations necessary for an open, experimentation-friendly workflow.
Three primary categories differentiate this build from the upstream:
Telemetry Removed: Outbound telemetry endpoints are eliminated or stubbed. The build preserves local feature gating via GrowthBook while ensuring that analytics, crash reports, and session fingerprinting do not leave traces to remote services.
Security Prompt Guardrails Removed: Anthropic’s server-side and prompt-level constraints are stripped of injections that would otherwise push hardcoded safety overlays into conversations. The model’s own safety rails remain, but the additional, externally enforced guardrails are removed to provide a more direct interaction surface for advanced users.
Experimental Features Unlocked: The codebase ships with a wide array of feature flags that enable deeper experimentation. While the public npm release disabled many flags, this build unlocks a substantial portion (54 flags that compile cleanly), allowing researchers and developers to explore capabilities beyond the standard production feature set.
The prose underscores a deliberate trade-off: the project enables broader experimentation at the cost of built-in telemetry and additional guardrails. It is framed as a tool for power users who want to probe performance, behavior, and novel interaction patterns in a controlled, self-directed environment.
The architectural emphasis is on modularity and transparency—an explicit invitation to inspect, modify, and contribute the underlying feature flags, models, and integration points.

Model Providers: Flexible Access to Multiple AI Engines

The Free-Code ecosystem natively supports five API providers, enabling switchable backends through environment variables with no code changes. This design choice prioritizes flexibility and interoperability across organizations and talent pipelines.
Anthropic (Direct API) — Default:
Models and IDs include Claude Opus 4.6 (claude-opus-4-6), Claude Sonnet 4.6 (claude-sonnet-4-6), and Claude Haiku 4.5 (claude-haiku-4-5).
The default pathway uses Anthropic’s first-party API, which means you can access these Claude family models directly by configuring the appropriate API keys or OAuth flows.
OpenAI Codex:
Models include GPT-5.3 Codex (gpt-5.3-codex), GPT-5.4 (gpt-5.4), and GPT-5.4 Mini (gpt-5.4-mini).
Requires a Codex subscription to operate, and the provider switch is controlled by a simple environment flag (CLAUDECODEUSE_OPENAI=1).
AWS Bedrock:
Invocation passes through your AWS account via Amazon Bedrock. Users map to Bedrock ARNs automatically (for example, us.anthropic.claude-opus-4-6-v1).
Essential environment variables include CLAUDECODEUSEBEDROCK, AWSREGION, and credentials (standard AWS authentication mechanisms).
Optional overrides include ANTHROPICBEDROCKBASEURL, AWSBEARERTOKENBEDROCK, and CLAUDECODESKIPBEDROCKAUTH for testing.
Google Cloud Vertex AI:
Accessed by enabling CLAUDECODEUSE_VERTEX and authenticating via Google Cloud Application Default Credentials (gcloud auth application-default login).
Model mappings translate to Vertex AI naming patterns (e.g., claude-opus-4-6@latest).
Anthropic Foundry:
A pathway to dedicated deployments by setting CLAUDECODEUSE_FOUNDRY and providing an Anthropic Foundry API key.
Supports custom deployment IDs as model names, enabling bespoke deployments beyond standard public offerings.
Provider Selection Summary (quick reference):
Anthropic (default): ANTHROPICAPIKEY or OAuth for authentication.
OpenAI Codex: CLAUDECODEUSE_OPENAI=1; OAuth-based OpenAI authentication.
AWS Bedrock: CLAUDECODEUSE_BEDROCK=1; AWS credentials via environment.
Google Vertex AI: CLAUDECODEUSE_VERTEX=1; Google Cloud ADC.
Anthropic Foundry: CLAUDECODEUSE_FOUNDRY=1; Foundry API key.
This multi-provider design is intended to maximize resilience and experimentation: teams can compare model behaviors, latency, and cost profiles across ecosystems without changing the codebase, simply by adjusting environment settings.

Requirements: What Is Needed to Run Free-Code

Runtime: Bun (a modern JavaScript runtime) must be present, with a minimum version of 1.3.11. Bun is chosen for speed, packaging efficiency, and the ability to execute TypeScript-based tooling directly without a separate transcompilation step.
Operating System: The build targets macOS or Linux environments, with Windows support achievable through Windows Subsystem for Linux (WSL). This broad compatibility recognizes typical developer environments and avoids platform-specific bottlenecks.
Authentication: Users must provide an API key or OAuth login for their chosen provider. The design assumes you will supply credentials for Anthropic, OpenAI, AWS Bedrock, Google Vertex AI, or Foundry, depending on your selection.
Build-time prerequisites: The Quick Install pathway implies a locally available internet connection to fetch and install Bun if missing, clone the repository, and perform a build. This is a one-shot step that yields a binary suitable for ongoing usage.
Optional tooling: While not strictly required for basic operation, the ecosystem includes a scriptable build system with Bun, scripts/build.ts for enabling specific flags, and a number of environment variables that tailor authentication, endpoints, and model mappings.

Build Process: How the Binary Is Created

Core commands:
git clone https://github.com/paoloanzn/free-code.git
cd free-code
bun build
./cli
Build variants and outputs:
bun run build: Produces the main production-like binary at ./cli with VOICE_MODE enabled by default.
bun run build:dev: Produces a development version at ./cli-dev, including a version stamp to mark it as a dev build.
bun run build:dev:full: Unlocks all 54 experimental flags, resulting in a fully feature-rich dev binary at ./cli-dev.
bun run compile: Alternative output path at ./dist/cli with VOICE_MODE enabled.
Feature flag control:
Custom feature flags can be selectively enabled without the full bundle by using the build script with explicit flags (for example, --feature=ULTRAPLAN and --feature=ULTRATHINK).
This enables targeted experimentation in local environments without the overhead of a complete flag sweep.
Build philosophy:
The build system relies on a flag-driven approach to enable or disable features, allowing a continuous integration-like workflow where teams can test specific capabilities, measure impact, and gradually expand the feature surface.
The presence of a “full unlock” path signals a willingness to push the tool to its conceptual limits, while the production-like path remains suitable for day-to-day coding tasks and stable experimentation.

Usage: Interacting with Free-Code

Interactive REPL (default): Run ./cli to enter an interactive session where prompts and responses feel like a conversational assistant integrated into the terminal.
One-shot mode: Use ./cli -p "What files are in this directory?" to perform a single query and receive a concise answer, suitable for scripting or quick checks.
Specifying a model: Use ./cli --model claude-opus-4-6 to pin a particular Claude model for a session or task.
Run from source: bun run dev for slower startup but direct development feedback, enabling rapid iteration during code changes.
OAuth login: The /login command provides a streamlined path to authenticate with your provider, ensuring that subsequent prompts and actions have the necessary authorization.
Environment variables (selected examples):
ANTHROPICAPIKEY: Your key for Anthropic API access.
ANTHROPICAUTHTOKEN: An alternative authentication token.
ANTHROPIC_MODEL: Optional override for the default model.
ANTHROPICBASEURL: Custom API endpoint, if you’re using a private or self-hosted variant.
ANTHROPICDEFAULTOPUS_MODEL / SONNET / HAIKU: Convenience defaults for common model choices.
CLAUDECODEOAUTH_TOKEN: Token-based OAuth flow in environments where token-based auth is preferred.
CLAUDECODEAPIKEYHELPERTTLMS: Cache TTL for the API key helper, to balance performance and security considerations.
Practical considerations:
The toolset is designed for power users who want direct control over providers, models, and authentication flows.
The interactive mode emphasizes a responsive, code-oriented assistant, while the non-interactive mode prioritizes deterministic outputs suitable for automation, documentation, or batch testing.

Experimental Features: A Rich Flag System for Deep Exploration

Core idea: The build:dev:full variant activates 54 working feature flags that alter behavior, interfaces, and capabilities in meaningful ways.
Major categories and highlights:
Interaction and UI:
- ULTRAPLAN: Remote multi-agent planning on Claude Code web interfaces (Opus-class capabilities). Enables structured planning across multiple sub-agents to tackle complex tasks.
- ULTRATHINK: A deep thinking mode; users can type ultrathink to boost reasoning effort, prompting the model to allocate more tokens and processing cycles toward a thorough solution.
- VOICE_MODE: Push-to-talk voice input and dictation integration, enabling hands-free interaction and potential accessibility enhancements.
- TOKEN_BUDGET: Tracking of token usage and warnings when usage approaches predefined budget thresholds.
- HISTORY_PICKER: An interactive prompt history picker for selecting prior prompts and responses, streamlining iterative exploration.
- MESSAGE_ACTIONS: Additional action entrypoints in the UI to manipulate, annotate, or execute operations on messages.
- QUICK_SEARCH: Prompt quick-search, enabling rapid retrieval of context, prompts, or results.
- SHOT_STATS: Visualization of shot-distribution statistics to understand model behaviors across tasks.
Agents, Memory, and Planning:
- BUILTINEXPLOREPLAN_AGENTS: Prebuilt agents for exploration and planning, facilitating structured experimentation.
- VERIFICATION_AGENT: A dedicated verifier for task validation, ensuring outputs meet expected criteria.
- AGENTTRIGGERS / AGENTTRIGGERS_REMOTE: Scheduling and remote trigger paths for automation around prompts, responses, or context updates.
- EXTRACT_MEMORIES: Automatic extraction of memories from post-query contexts to improve continuity and recall across sessions.
- COMPACTION_REMINDERS: Smart reminders related to context compaction, helping manage token budgets while preserving essential history.
- CACHED_MICROCOMPACT: A cached microcompact state that helps streamline repeated queries by preserving condensed representations.
- TEAMMEM: Team-memory files and watcher hooks to support collaborative workflows.
Tools and Infrastructure:
- BRIDGE_MODE: An IDE bridge for remote control (e.g., VS Code, JetBrains), enabling editing and command execution in an integrated development environment.
- BASH_CLASSIFIER: A classifier-guided permission decision layer for bash-related commands, potentially preventing unintended shell actions.
- PROMPTCACHEBREAK_DETECTION: Cache-break detection in compaction and query flows to maintain accuracy when caches become stale.
Documentation note: The full audit of 88 flags is documented in FEATURES.md (with a dedicated section on 34 flags that are broken and notes on reconstruction). This indicates an active, transparent experimentation environment where changes, trade-offs, and recovery steps are recorded for researchers and contributors.
Practical implication: Activating these flags unlocks capabilities that transform how users may interact with the model, how tasks are planned and tracked, and how memory and context are managed across sessions. It invites robust experimentation but also demands careful handling to avoid instability or unintended side effects.

Project Structure: A Modular, Developer-Centric Organization

The repository is organized around a clear separation of concerns, designed to support both end users and contributors who wish to modify or extend functionality.
Key components and their roles:
scripts/ build.ts: The orchestration layer that handles the feature flag system and build-time wiring. It centralizes logic for enabling specific flags and orchestrating the compilation workflow.
src/: Core source code and logic that implement the command-line interface, providers, and model interactions.
entrypoints/cli.tsx: The CLI entrypoint that registers commands and defines the user-facing command surface.
commands.ts: Command registry that maps slash commands to functional implementations.
tools.ts: Tool registry that binds agent tools and utilities (read, edit, etc.) to the CLI surface.
screens/REPL.tsx: The main interactive UI, built with Ink/React, delivering a terminal-based interactive experience.
components/: UI components that render the terminal interface and manage layout.
hooks/: React hooks for state management and side-effect handling within the terminal UI.
services/: API clients, MCP, OAuth, and analytics integration.
oauth/: OAuth flows for Anthropic and OpenAI, enabling seamless authentication workflows.
state/: App state store for persistence of user preferences and session data.
utils/: Utility functions used across modules.
model/: Model configurations, provider integrations, and validation logic to ensure that model selection and invocation adhere to expected formats.
skills/: Skill system that maps user intents to model-assisted actions.
plugins/: Plugin system to extend functionality with external modules.
bridge/: IDE bridge logic for the VS Code and JetBrains integrations.
voice/: Voice input features and processing.
tasks/: Background task management for scheduled jobs and automation.
This composition supports a robust developer experience, enabling rapid experimentation, straightforward debugging, and straightforward extension by third-party contributors.

Tech Stack: Choices Driving Performance and Leniency for Experimentation

Runtime:
Bun as the primary runtime, chosen for speed, native TypeScript support, and streamlined packaging in a CLI-oriented project.
Language:
TypeScript, offering strong typing, improved maintainability, and better tooling for a large, feature-rich codebase.
Terminal UI:
Ink in combination with React, enabling a familiar component-based approach to building terminal interfaces with reactive updates.
CLI Parsing:
Commander.js is used to define and parse CLI commands, flags, and subcommands in a predictable and well-supported manner.
Schema Validation:
Zod v4 is used to validate inputs, models, and configuration objects, ensuring correctness across a variety of runtime scenarios.
Code Search:
ripgrep (rg) is bundled for fast, efficient searching within the repository.
Protocols and APIs:
MCP and LSP as core interaction protocols, facilitating structured command and language service interactions.
APIs include initiative integrations with Anthropic Messages, OpenAI Codex, AWS Bedrock, and Google Vertex AI, reflecting a multi-provider model strategy.
This stack balances performance with developer ergonomics, enabling a flexible toolset that remains approachable for contributors while retaining the power required for deep experimentation.

IPFS Mirror: Permanence Through Distributed Tracking

An IPFS mirror of the repository is provided for redundancy and permanence, ensuring a long-term, decentralized copy persists even if primary hosting changes.
Core details:
CID: bafybeiegvef3dt24n2znnnmzcud2vxat7y7rl5ikz7y7yoglxappim54bm
Gateway: https://w3s.link/ipfs/bafybeiegvef3dt24n2znnnmzcud2vxat7y7rl5ikz7y7yoglxappim54bm
Practical benefits:
A distributed snapshot supports resilience against takedowns or platform outages.
It provides researchers and developers with a stable reference point for the exact codebase and configurations used in this feature-rich build.
The IPFS mirror reinforces a commitment to openness and long-term accessibility, aligning with the project’s ethos of experimentation and collaboration.

Contributing: How to Engage with the Project

Contributions are welcomed, particularly tasks related to restoring or improving one of the 34 broken feature flags or refining reconstruction notes.
Typical workflow steps: 1) Fork the repository to your GitHub account. 2) Create a feature branch (for example, feat/my-feature). 3) Commit changes with a descriptive message (feat: add something). 4) Push the branch to the origin repository. 5) Open a Pull Request to propose your changes to the main branch.
The process emphasizes incremental, testable contributions that align with the feature flag model. It also encourages contributors to consult the reconstruction notes in FEATURES.md before attempting fixes, ensuring changes are coherent with the audit trail and intended repair strategies.
The community invitation is clear: collaborate to extend capabilities, improve stability, and explore new interaction paradigms enabled by the unlocked flags.

Licensing and Ethical Considerations: Framing and Boundaries

The Free-Code project positions itself as a fork of Claude Code, with the upstream origin being Anthropic’s Claude Code. The textual license summary notes that the original Claude Code source is the property of Anthropic, and this fork exists due to the public exposure of the source in a distribution channel.
A practical takeaway is that users must exercise discretion, particularly with a build that removes guardrails and telemetry. The narrative frames usage as “at your own discretion,” inviting responsible experimentation while acknowledging the legal and ethical boundaries of using competing or restricted tooling.
The license section signals a caveat: while the code is accessible and modifiable, it remains entangled with the original proprietary lineage and its licensing constraints. Teams should ensure compliance with applicable terms when integrating, deploying, or distributing modified builds.

Summary: A Tool for Advanced Exploration and Collaboration

Free-Code is framed as an unapologetically open, highly configurable, and feature-rich fork of Claude Code that invites developers to push the boundaries of AI-assisted coding in the terminal.
The architecture supports a modular, provider-agnostic approach to model access, enabling seamless switching between Anthropic, OpenAI Codex, AWS Bedrock, Google Vertex AI, and Anthropic Foundry without changing source code.
The project’s emphasis on telemetry removal, guardrail deactivation, and 88 feature flags underscores a commitment to transparency, experimentation, and collaborative development—ideal for researchers, advanced users, and teams exploring future directions in AI-assisted coding tools.
At its core, Free-Code blends a robust command-line experience with a flexible, multi-provider AI backend, all organized around a developer-friendly project structure, a thorough feature flag system, and a distributed approach to code persistence through IPFS.

Appendix: Quick Reference Snippets (Conceptual)

Quick Install concept: curl -fsSL https://raw.githubusercontent.com/paoloanzn/free-code/main/install.sh | bash
Run-time prerequisites concept: Bun >= 1.3.11; macOS or Linux; API keys or OAuth credentials
Provider enablement concept: export CLAUDECODEUSE_OPENAI=1 (switch to OpenAI Codex)
Dev vs. prod concept: bun run build (production-like), bun run build:dev:full (full feature unlock), bun run build:dev (dev with a stamp)
IPFS mirror concept: bafybeiegvef3dt24n2znnnmzcud2vxat7y7rl5ikz7y7yoglxappim54bm for permanence and decentralized access

Final Note: Embracing Open Exploration

The assembled description emphasizes a project designed for hands-on experimentation with a focus on control, visibility, and extensibility.
It is a resource for developers who want to understand the inner workings of a Claude Code-like CLI, to test the boundaries of model providers, to experiment with a wide array of feature flags, and to contribute to a shared, evolving codebase that prioritizes openness and collaboration.
The included image at the top serves as a visual anchor for this narrative, while the structured sections provide a comprehensive map of the tool’s capabilities, dependencies, and workflows.

free-code: The free build of Claude Code

Enjoying this project?

GitHub - paoloanzn/free-code: free-code: The free build of Claude Code

Stay Updated

Product

Learn

Company

Legal

Stay Updated