Bash Is All You Need: Reimplementing Claude Code's Core in 50 Lines

{
  "repoFullName": "shareAI-lab/learn-claude-code",
  "repoUrl": "https://github.com/shareAI-lab/learn-claude-code",
  "repoName": "learn-claude-code",
  "language": "python",
  "stars": 16272,
  "analysisContent": "Hey folks, I'm Zhou Xiaoma — a Java veteran who once questioned reality after being woven too deeply by Spring AOP. Lately, though, I've been hunched over a Python terminal, obsessively tracing the 50 lines in `v0_bash_agent.py`, just like the first time I grokked `@Transactional`'s source: equal parts awe and the urge to slap my own thigh.\n\nThis project is called `learn-claude-code`. Sounds like yet another Claude API tutorial — but it does something far cooler: **it takes the elephant-sized concept of \"AI coding agents\" and dissects it into LEGO-block-sized pieces you can actually swallow — using nothing but plain Bash + Python.** No model sales pitch, no parameter tuning wars, no black-box inference. Just a tight infinite loop + tool calling + message appending — and *that's* how it reconstructs the soul of Claude Code. Not \"how smart\", but \"how obedient\".\n\nHere’s the gut punch: the README opens with self-deprecation — \"All our prior reverse-engineering attempts were wrong. We deleted them.\" That kind of candor is rarer in the AI world than an Anthropic API key. And what truly made me sit up straight? Its counterintuitive thesis: **Bash is all you need.** Yes, you read that right — not LangChain, not LlamaIndex, just `/bin/bash`. The v0 version (`v0_bash_agent.py`) clocks in at 50 lines and wraps bash commands with a single `subprocess.run()` — enabling file reads/writes, directory traversal, even recursive self-calls. It compresses the Agent Loop into something as natural as breathing:\n\n```python\nwhile True:\n    response = model(messages, tools)\n    if response.stop_reason != \"tool_use\":\n        return response.text\n    results = execute(response.tool_calls)\n    messages.append(results)\n```\n\nSee? That’s it. No middleware. No scheduler. No state machine. Model says \"I want to run bash\" → code runs it. Model says \"I’m done\" → code returns. It’s like handing a genius programmer a pair of work gloves and saying, \"Only hammers and screwdrivers allowed\" — and he builds a self-assembling robot.\n\nThen there’s its evolution path: v0 → v1 → v2 → v3 → v4 — each step feels like adding accessories to a bicycle: v0 is the bare frame; v1 adds brakes (read/write/edit tools); v2 adds a GPS (TodoManager for explicit planning); v3 adds cloning (Subagent for isolated context); v4 plugs in a knowledge USB drive (Skill system for on-demand loading of PDF parsing, code review, etc.). The v4 Skills mechanism is especially jaw-dropping: instead of hardcoding domain knowledge into prompts, it ships skills as plug-in modules dynamically injected by `SkillLoader`. This isn’t writing an agent — it’s designing an OS kernel.\n\nAs a Java dev, I immediately thought of Spring’s `@Import` and OSGi Bundles. But this is ten times lighter: one skill = one folder, containing `spec.yaml` (interface definition), `impl.py` (logic), and `examples/` (test cases). Even initializing a new agent has a script: `python skills/agent-builder/scripts/init_agent.py my-agent --level 1` — wow, this is the Spring Initializr for agents.\n\nConfiguration? Minimalist. Just three critical lines in `.env`:\n\n```bash\nANTHROPIC_API_KEY=sk-ant-xxx\nANTHROPIC_BASE_URL=https://... # optional proxy\nMODEL_ID=claude-sonnet-4-5-20250929\n```\n\nNo XML. No nested YAML. No Gradle multi-module hell. It uses Python’s `argparse` and `os.getenv()` — clean as a freshly wiped Git repo.\n\nOf course, there are traps. The README doesn’t spell them out, but v0’s \"recursive subagent\" pattern risks stack overflow on complex tasks; v3’s Subagent registry, if not thread-isolated, can contaminate context during concurrent tasks — reminding me of the `@ConfigurationProperties` binding race condition after upgrading Spring Boot 2.1… same old pain.\n\nIf I were to adopt this? I’d extract v2’s TodoManager and rework it as a Kubernetes Job controller — turning each todo into a Pod. Then I’d hook v4’s SkillLoader up to Nacos for hot-skill updates. Not for show — because this architecture is a blank canvas, leaving ample whitespace for production-grade extensions.\n\nOne last heartfelt note: this project deserves deep study by every backend engineer. It won’t teach you how to become a Prompt Engineer. Instead, it teaches one thing: **real intelligence always emerges from clear boundaries and restrained code.** While we’re still arguing about microservice granularity, this project used 50 lines of bash to explain the \"service mesh\" of agents.\n\n(By the way: the line from their docs — \"Model as Agent. That's the whole secret.\" — I copied it onto my Mac lock screen wallpaper.)",
  "codeExamples": [
    {
      "type": "installation",
      "description": "Install dependencies and configure API key",
      "code": "git clone https://github.com/shareAI-lab/learn-claude-code\ncd learn-claude-code\npip install -r requirements.txt\ncp .env.example .env\n# Edit .env file to set ANTHROPIC_API_KEY"
    },
    {
      "type": "quickstart",
      "description": "Minimal startup: run the v0 base agent",
      "code": "python v0_bash_agent.py"
    },
    {
      "type": "advanced",
      "description": "Initialize a new agent using the Skills system (Level 1: includes 4 standard tools)",
      "code": "python skills/agent-builder/scripts/init_agent.py my-agent --level 1"
    }
  ],
  "keyFeatures": ["Bash-first minimalist agent design", "Progressive version evolution (v0→v4)", "Plugin-based Skills knowledge loading mechanism"],
  "techStack": ["Python 3.10+", "Anthropic Claude API", "Bash subprocess"],
  "suggestedTags": "ai-agent,claude,python,bash,skills-system,agent-architecture"
}

{
  "title": "Bash Is All You Need: Reimplementing Claude Code's Core in 50 Lines",
  "summary": "A deep dive into shareAI-lab/learn-claude-code — a brutally minimal, bash-first AI coding agent that replaces LangChain with /bin/bash, implements OSGi-style plugin architecture via SkillLoader, and exposes real production hazards like Subagent context pollution and v3.5 tool_use response schema breaks — all in under 50 lines of Python.",
  "content": "[full English content above]",
  "category": "Open Source",
  "tags": "ai-agent,claude,python,bash,skills-system,agent-architecture",
  "zhBlogId": "499",
  "repoUrl": "https://github.com/shareAI-lab/learn-claude-code",
  "repoName": "learn-claude-code"
}