Agent Engineering on ICE-ICE-BEAR-BLOG

Learning Agents: Course or Catalog? Microsoft AI Agents for Beginners vs. Awesome LLM Apps

Sun, 10 May 2026 00:00:00 +0900

Overview

Two learning resources surfaced alongside each other this week and form a striking contrast. One is Microsoft’s ai-agents-for-beginners — a structured 12+ lesson curriculum. The other is Shubham Saboo’s awesome-llm-apps — a catalog of 100+ ready-to-run templates. Both are massive (61k and 109k stars respectively), and they answer the same question — “how do I learn to build AI agents?” — in opposite ways.

flowchart LR
 Learner["agent beginner"]
 Curriculum["ai-agents-for-beginners <br/> 12+ lesson course"]
 Catalog["awesome-llm-apps <br/> 100+ template buffet"]
 Goal1["concept → code → production"]
 Goal2["fork what is closest to my use case"]
 Gap["what is missing: eval, observability, cost"]

 Learner --> Curriculum
 Learner --> Catalog
 Curriculum --> Goal1
 Catalog --> Goal2
 Goal1 --> Gap
 Goal2 --> Gap

Two repos, two identities

Microsoft AI Agents for Beginners — the course

microsoft/ai-agents-for-beginners is an official Microsoft learning course that has crossed 61k stars. MIT-licensed, Jupyter-Notebook-based, started in November 2024, and built around Microsoft Agent Framework plus Azure AI Foundry Agent Service V2. The lesson tree:

01 Intro to AI Agents and Agent Use Cases
02 Exploring Agentic Frameworks
03 Agentic Design Patterns — UX principles for Space/Time/Core
04 Tool Use Design Pattern
05 Agentic RAG
06 Building Trustworthy AI Agents
07 Planning Design Pattern
08 Multi-Agent Design Pattern
09 Metacognition Design Pattern
10 AI Agents in Production — observability + evaluation
11 Agentic Protocols (MCP, A2A, NLWeb)
12 Context Engineering for AI Agents
13 Managing Agentic Memory
14 to 18 cover Microsoft Agent Framework deep-dive, Browser-Use-style Computer Use Agents, and Securing AI Agents

Each lesson ships as text + short video + Jupyter notebook code samples. The course is also auto-translated into 50+ languages through co-op-translator — for example a Korean translation. If translation bloat bothers you, the README suggests a git sparse-checkout recipe to skip translation directories.

Awesome LLM Apps — the catalog

On the other side, Shubhamsaboo/awesome-llm-apps is a 109k-star template repository. Apache-2.0 licensed, and the README opens with “100+ AI Agent & RAG apps you can actually run — clone, customize, ship.” The author is explicit that this is “hand-built, not curated” — every template is original work, tested end-to-end. It is organized into 13 categories:

Starter AI Agents — single-file agents with one API key
Advanced AI Agents — memory, tools, multi-step reasoning
Multi-agent Teams — CrewAI-based services agency, etc.
Voice AI Agents — real-time speech interfaces
MCP AI Agents — Model Context Protocol integrations
RAG Tutorials — 21+ variants including Agentic RAG, Corrective RAG, Vision RAG
Awesome Agent Skills — 19 reusable skill files for Claude Code / ADK
LLM Fine-tuning (Gemma 3, Llama 3.2)
Google ADK Crash Course and OpenAI Agents SDK Crash Course

Each template has its own README, a requirements.txt, and usually a one-liner like streamlit run. The promise on the tin is “your first agent running in 30 seconds.”

Same topic, different depth — Lesson 03 vs. catalog 03

Looking at the same subject — “agent design principles” — from both sides shows how the two formats differ.

Dimension	MS 03-agentic-design-patterns	Awesome LLM Apps Starter
Starting point	UX principles like “Connecting not collapsing” and “Embrace uncertainty”	Runnable code such as AI Travel Agent
Length	Thousands of words, diagrams, a Travel Agent case study	Short README + run command
Method	Principles → guidelines (Transparency/Control/Consistency) → application	Working code → poke at it, learn by feel
Next action	Proceed to lesson 04 (Tool Use)	Branch into one of 30 sibling templates

The first teaches “why design it this way.” The second says “someone already designed it this way — fork and tweak.” Both are correct answers to different starting positions.

Who fits which

The course fits

Beginners who need fundamentals — UX principles, design patterns, multi-agent, memory, and context engineering are covered systematically
Azure shops — Azure AI Foundry plus Microsoft Agent Framework maps cleanly onto the lessons
Non-English learners who want a translation — Korean, Japanese, Simplified Chinese, and 50+ more
Anyone needing a deck for a CIO — clean chapter structure like “MCP / A2A / NLWeb compared” doubles as briefing material

The catalog fits

Engineers who already do LLM calls and want to compare patterns — for example, 21 RAG variants side by side to pick the one closest to their case
People with a clear use case — domains like insurance, investment, research, or voice get direct starters: Insurance Claim Live Agent, AI VC Due Diligence
Side-project hunters — AI 3D Pygame Agent or AI Meme Generator are easy entry points
People learning a specific stack — MCP, CrewAI, or ADK-specific examples to study

Roughly: the course is for “I want a path,” the catalog is for “I want a buffet.” The best use is to combine them. Read MS lesson 05 Agentic RAG, then clone Agentic RAG with Reasoning from the catalog and run it — theory and working code lock in together.

What beginner content systematically misses

Looking across both repos — and at the rest of the “agent 101” market — there are areas where beginner content is consistently underweight.

1. Evaluation gets one lesson, not a course. MS does cover trace/span, offline/online eval, RAGAS, and LLM Guard in Lesson 10, but that is one chapter near the end. awesome-llm-apps has the RAG Failure Diagnostics Clinic, which is interesting, but eval is not a top-level category. In practice teams spend far more time figuring out why an agent regressed than building it.

2. Observability is treated as an “in production” feature. OpenTelemetry, Langfuse, and Microsoft Foundry appear, but framed as production-grade tooling. The reality is that the first time you wire up a multi-step agent, you need traces on. Debugging a multi-agent system without traces is like debugging multi-threaded code without print statements.

3. Cost simulation is absent. awesome-llm-apps does include Toonify Token Optimization and Headroom Context Optimization, but a beginner has no sense that one multi-agent run can burn 5x to 50x more tokens than they expect. Lesson 01 in any agent course should hand the learner a calculator: “if you demo this 100 times this week, here is the bill.”

4. There is no canonical failure-mode catalog. “Here is something that works” gets shown; “here is how it breaks” rarely does. Prompt injection, runaway tool loops, memory leaks, agents trusting their own RAG output blindly — these patterns show up every week in production. The community surfaced this around the same time with a one-liner that lands: building agents is easy, memorizing how they break is the actual job.

Insights

Agent learning content has graduated in the last year from “framework comparison” to “real curriculum.” That MS ships 12+ lessons covering design patterns and protocols is itself a market-maturity signal. At the same time, awesome-llm-apps showing 100+ templates that cover ADK, OpenAI Agents SDK, CrewAI, and MCP and still all run with one streamlit run line says the cost of building a working agent has dropped to a floor. Used together — concepts from the course, first running code from the catalog — they form a clean learning loop. But both, and effectively the entire market, are still thin on evaluation, observability, cost, and failure modes. That gap is the content opportunity of the next year. When “AI Agents Eval for Beginners” or “Agent Observability for Beginners” exists at the same quality bar, the field will have matured one more step.

References

The Microsoft course

Awesome LLM Apps

Shubhamsaboo/awesome-llm-apps — the repo
Unwind AI — the author’s tutorial site
Google ADK Crash Course
OpenAI Agents SDK Crash Course

Evaluation and observability tools

Protocols and frameworks referenced

The Claude Code Skills Explosion — What Five Repos in One Day Are Telling Us

Sun, 10 May 2026 00:00:00 +0900

Overview

Five Claude Code skill and agent collection repos surfaced around the same time on 2026-05-10. One is Andrej Karpathy’s own autonomous research agent. One is Matt Pocock’s engineering-grade skill set. One is a full meta-framework called SuperClaude. This is not a coincidence — it is a sign that “skill” has crystallized into the primary primitive for agent engineering.

graph TD
 Pattern["skills pattern"] --> K["karpathy/autoresearch <br/> 80K stars"]
 Pattern --> F["forrestchang/andrej-karpathy-skills <br/> 123K stars"]
 Pattern --> A["hesreallyhim/awesome-claude-code <br/> 43K stars"]
 Pattern --> S["SuperClaude_Framework <br/> 22K stars"]
 Pattern --> M["mattpocock/skills <br/> 69K stars"]

 K --> Primitive["program.md = skill"]
 F --> Primitive
 M --> Primitive
 S --> Primitive
 A --> Curation["awesome-list curation"]

Why Skills Are Crystallizing

A skill is the pattern Anthropic formalized in fall 2025. The format is dead simple — a folder, a SKILL.md, optional helper scripts. Claude Code looks at the user’s task context and decides which skill to invoke itself.

That simplicity is the reason for the explosion.

Version-controllable — it’s just text. Review with git diff, accept PRs against it.
Composable — one skill can call another. /grill-me → /to-prd → /to-issues → /tdd becomes a natural pipeline.
Model-agnostic in spirit — Claude Code is the first mover, but the format is markdown, so it ports trivially. SuperGemini and SuperQwen forks already exist.
Shareable — pull an entire repo into your agent with /plugin marketplace add.

These five repos are five facets of that pattern crystallizing.

1. karpathy/autoresearch — Skill as a Research Agent’s program.md

karpathy/autoresearch sits at 80,223 stars. Created 2026-03-06, “AI agents running research on single-GPU nanochat training automatically.”

The idea is simple. Hand an AI agent a small but real LLM training setup and let it experiment overnight. Modify code → train 5 min → compare → keep or discard → repeat. You wake up to a log of experiments and (hopefully) a better model.

The structure is what matters.

prepare.py — constants, data prep (do not modify)
train.py — model/optimizer/training loop (agent edits this)
program.md — agent instructions (human edits this)

Karpathy himself states it in the README:

The program.md file is essentially a super lightweight “skill”.

That’s the line. Karpathy chose the word “skill.” Not a 10,000-line framework wrapping autonomous research orchestration on top of nanochat training code — one markdown file. The human evolves program.md. The agent evolves train.py. Two meta-evolution loops, cleanly separated.

Why this matters — Karpathy is the last person you’d expect to outsource a training setup. If he ends at one markdown file, everyone else has license to simplify harder.

2. forrestchang/andrej-karpathy-skills — Skills as Behavioral Correction

forrestchang/andrej-karpathy-skills has 123,691 stars. “A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy’s observations on LLM coding pitfalls.”

It distills four principles from Karpathy’s X post on LLM coding pitfalls.

Principle	Addresses
Think Before Coding	Wrong assumptions, hidden confusion, missing tradeoffs
Simplicity First	Overcomplication, bloated abstractions
Surgical Changes	Touching unrelated code, “improving” things you shouldn’t
Goal-Driven Execution	Loop until verifiable success criteria

Installation is two paths — /plugin marketplace add forrestchang/andrej-karpathy-skills for Claude Code, or curl the CLAUDE.md into your project. The same ruleset is committed as .cursor/rules/karpathy-guidelines.mdc for Cursor.

The thesis quote:

“LLMs are exceptionally good at looping until they meet specific goals… Don’t tell it what to do, give it success criteria and watch it go.” — Karpathy

This is skills used as a ruleset that corrects model behavior. Not adding capabilities — subtracting failure modes.

3. mattpocock/skills — Skills For Real Engineers

mattpocock/skills sits at 69,128 stars, MIT, last pushed 2026-05-10. “Skills for Real Engineers. Straight from my .claude directory.”

This repo stakes out an explicit position against full-process frameworks like GSD, BMAD, and Spec-Kit. The README is blunt:

Approaches like GSD, BMAD, and Spec-Kit try to help by owning the process. But while doing so, they take away your control and make bugs in the process hard to resolve.

These skills are designed to be small, easy to adapt, and composable. They work with any model.

Matt’s four failure modes and their skills:

Failure mode	Skill
#1 The Agent Didn’t Do What I Want	`/grill-me`, `/grill-with-docs`
#2 The Agent Is Way Too Verbose	`CONTEXT.md` shared language (built into grill-with-docs)
#3 The Code Doesn’t Work	`/tdd`, `/diagnose`
#4 We Built A Ball Of Mud	`/to-prd`, `/zoom-out`, `/improve-codebase-architecture`

Installation goes through the skills.sh installer:

npx skills@latest add mattpocock/skills

After install, /setup-matt-pocock-skills configures your issue tracker (GitHub / Linear / local files), your triage label vocabulary, and your doc storage path. From there, to-issues, to-prd, triage, diagnose, tdd, improve-codebase-architecture, and zoom-out all wire together against the same convention.

Pocock’s reading list is itself a signal — Pragmatic Programmer, Domain-Driven Design, Extreme Programming Explained, A Philosophy of Software Design. The argument: skills are not a new paradigm, they are an LLM-shaped interface to 30 years of software engineering practice.

4. SuperClaude_Framework — A Meta-Programming Layer On Top of Skills

SuperClaude-Org/SuperClaude_Framework has 22,726 stars, MIT, homepage superclaude.netlify.app. Created 2025-06-22.

Opposite pole from skill minimalism.

Metric	Count
Slash Commands	30
Specialized AI Agents	20
Behavioral Modes	7
MCP Servers	8

Self-described as “a meta-programming configuration framework that transforms Claude Code into a structured development platform through behavioral instruction injection and component orchestration.”

Install via PyPI:

pipx install superclaude
superclaude install

Headline commands — /sc:research (deep research, Tavily MCP), /sc:brainstorm, /sc:implement, /sc:test, /sc:pm. Optional MCP servers — Serena (2-3x faster code understanding), Sequential (30-50% fewer tokens), Tavily, Context7 — all routed through airis-mcp-gateway.

v5.0 is in development, with a TypeScript plugin system tracked in issue #419. Once shipped, install drops to /plugin marketplace add SuperClaude-Org/superclaude-plugin-marketplace.

What SuperClaude proves — skills are stable enough that a meta-framework can rest on top of them without collapsing. And the fact that the same format ports to Gemini and Qwen is empirical evidence of model-neutrality.

5. hesreallyhim/awesome-claude-code — The Curation Layer

hesreallyhim/awesome-claude-code has 43,273 stars, created 2025-04-19 — the oldest of this set. “A curated list of awesome skills, hooks, slash-commands, agent orchestrators, applications, and plugins for Claude Code by Anthropic.”

It follows the awesome-list convention. The repo’s topic tags are revealing — agentic-coding, agent-skills, ai-workflow-optimization, coding-agents. The README currently notes “the previous Table of Contents was no longer fit for purpose” and is mid-reorganization — which is itself the message. The Claude Code ecosystem has outgrown what one awesome-list can hold.

Why this repo belongs in the set: the other four provide new skills. This repo solves where to find them. Curation is itself a meta-skill.

Insights

1. Skill is now the consensus primitive. Five different people, five different angles, all settling on the same word. Karpathy’s program.md, Matt Pocock’s SKILL.md, SuperClaude’s slash commands — all framed as “skills.” The prior generation of terms (“prompt template”, “agent rules”, “system message”) has collapsed into a single noun.

2. Full-process frameworks vs. micro-skills is the live fault line. SuperClaude (30 commands) and Matt Pocock (small, composable) surfacing the same day is coincidence, but the split is real. Both survive. The interesting move is Pocock explicitly naming GSD/BMAD/Spec-Kit as the opposition.

3. Skills are used to subtract failure modes, not just add capabilities. Forrest Chang’s Karpathy guidelines give the model no new abilities. They prevent behaviors. What Anthropic does at the model level with Constitutional AI, users now do at the workflow level with skills.

4. Skills are the substrate of model neutrality — Claude Code is just the first surface. SuperClaude maintains SuperGemini and SuperQwen forks. Forrest Chang ships a Cursor .mdc in the same repo. Matt Pocock writes “They work with any model” as a top-line selling point. As the format standardizes, IDE/model lock-in weakens.

5. The program.md pattern has reached training code. In autoresearch, the human-edited file and the agent-edited file are physically separated. If that generalizes, every automated codebase trends toward a human.md + agent-modifiable/ shape.

6. What comes next — skill marketplaces, skill SDKs, skill evals. /plugin marketplace exists. SuperClaude is listed on Smithery. skills.sh emerged as a separate installer. The missing pieces are quality evaluation (which skills actually improve model output) and a skill SDK (build/test skills as if they were code).

7. Curation itself becomes a skill. awesome-claude-code earning 43K stars is the symptom of “there are too many skills to triage manually.” That’s the cue for a meta layer.

References

Source repos

karpathy/autoresearch — Single-GPU nanochat autonomous research agent. Calls program.md a “lightweight skill” explicitly.
forrestchang/andrej-karpathy-skills — Four-principle CLAUDE.md derived from Karpathy’s LLM coding pitfall observations.
mattpocock/skills — Small, composable engineering skills. Explicit counter to GSD/BMAD/Spec-Kit.
SuperClaude-Org/SuperClaude_Framework — Meta-framework with 30 slash commands, 20 agents, 8 MCP servers.
hesreallyhim/awesome-claude-code — Awesome-list for Claude Code resources.

Background

Anthropic: Introducing Skills — Skill format formalization.
Claude Code docs: Plugins — /plugin marketplace system.
Karpathy’s LLM coding pitfalls tweet — Origin of the Forrest Chang guidelines.

Related

awesome-list convention — Format awesome-claude-code inherits.
skills.sh — Matt Pocock skill installer.
Smithery — MCP/skill marketplace.

Claude Code OS — A Bootable LiveUSB That Treats Claude Code as the Operating System

Sat, 09 May 2026 00:00:00 +0900

Overview

Hostingglobal-Tech/claude-code-os is a MIT licensed project created on 2026-05-01, sitting at about 85 stars: a bootable LiveUSB distro that launches Claude Code and OpenAI Codex CLI side by side in under a minute. The phrase “Claude Code OS” in the repo name is not a metaphor — the project literally builds a Linux Mint 21.3 XFCE live image where the AI agents are wired into the init sequence as userspace itself. The first thing you see after boot is not a desktop, it is two AI prompts.

graph TD
 Kernel["Linux kernel (Mint 21.3 XFCE base)"] --> Userland["Userspace = AI agents"]
 Userland --> Tab1["Left tab: Claude Code <br/> @anthropic-ai/claude-code"]
 Userland --> Tab2["Right tab: Codex CLI <br/> @openai/codex"]
 Userland --> Browser["Firefox (for OAuth)"]

 Persistence["cco-persistence.dat <br/> ext4 3.5 GB on USB"] --> Userland
 Persistence -. "Wi-Fi creds / OAuth / files" .-> Tab1
 Persistence -. "API keys / files" .-> Tab2

 Boot["Ventoy bootloader"] --> Kernel
 Boot --> Persistence

Why it exists — the install ritual in front of AI

The author’s framing on the README is blunt.

Talking to AI takes too many steps — install OS, drivers, browser, Node, npm, login. AI is the interface; why bolt an OS install ritual in front of it? So we made the OS itself AI.

Where agentmemory and agent-skills borrow the operating system metaphor to talk about agent context layers, claude-code-os drops the metaphor and literally wires the agent into the OS boot sequence: lightdm autologin → xfce4-terminal autostart → Claude Code + Codex CLI launched as the user’s first programs.

What is inside (v2.0.5)

The v2.0.5 release bundles:

Component	What	Notes
Base	Linux Mint 21.3 XFCE (Ubuntu 22.04 LTS jammy)	Conservative LTS
Left tab	`@anthropic-ai/claude-code`	npm global
Right tab	`@openai/codex`	npm global
Runtime	Node.js 20 LTS	NodeSource repo
Browser	Firefox	OAuth login only
Korean IME	ibus + ibus-hangul	`Shift+Space` toggle
Fonts	Noto Sans CJK KR + D2Coding	Korean readability
Locale	ko_KR.UTF-8 + Asia/Seoul	Korean-first
Autologin	lightdm `autologin-user=cco`	NOPASSWD sudo
Persistence	Ventoy `casper-rw` (3.5 GB)	Every state lives on the USB

The ISO weighs about 3.4 GB. GitHub release size limits forced a two-part split (aicode-os-v2.0.5.iso.part1 1.99 GB + part2 1.65 GB), reassembled with a single cat.

cat aicode-os-v2.0.5.iso.part1 aicode-os-v2.0.5.iso.part2 > aicode-os-v2.0.5.iso

Boot sequence — Claude Code as init

The whole build is one build-mint.sh (~18 KB). Inside a chroot it:

apt-installs ibus, ibus-hangul, fonts-noto-cjk, language-pack-ko, xfce4-terminal
Generates ko_KR.UTF-8 locale and sets Asia/Seoul timezone
Installs Node.js 20 LTS + npm install -g @anthropic-ai/claude-code @openai/codex
Pulls Naver D2Coding from its GitHub release (not in Ubuntu repos)
Creates the cco user with NOPASSWD sudo
Configures lightdm autologin-user=cco
Drops aicode-startup-claude and aicode-startup-codex into /usr/local/bin
Registers an XFCE autostart entry that runs xfce4-terminal --maximize --tab — one window, two tabs

The Claude launcher runs claude --dangerously-skip-permissions. That flag is the real meaning of “the OS is AI”: the agent operates with root privileges and full network, not as an ordinary user. There is no sandbox.

Persistence — every state lives on the USB

The other half of the design is Ventoy’s persistence plugin. A 3.5 GB ext4 image file cco-persistence.dat next to the ISO keeps the following inside the USB stick:

Wi-Fi SSIDs + passwords
Claude OAuth tokens
OpenAI API keys (or ChatGPT session cookies)
Working files, cloned repos, npm cache
ibus config and keyboard customizations

The host PC disk is never touched. Pull the USB out and the host has zero trace. Plug the same USB into a different machine and the entire environment follows: cafe laptop, meeting room PC, hotel desktop, all equivalent.

ventoy.json wiring is small.

{
 "control": [
 { "VTOY_DEFAULT_MENU_MODE": "0" },
 { "VTOY_MENU_TIMEOUT": "3" },
 { "VTOY_DEFAULT_IMAGE": "/aicode-os-v2.0.5.iso" }
 ],
 "persistence": [
 {
 "image": "/aicode-os-v2.0.5.iso",
 "backend": "/cco-persistence.dat",
 "autosel": 1
 }
 ]
}

Security model — host safe, USB risky

The README’s security section is unusually well-decomposed.

Area	Safe / Risky	Why
Host PC disk	Safe	LiveUSB writes only inside the USB
Workspace on USB	Risky	AI runs as root, executes what it is told
Outbound network	Risky	Full network, anything can leave
Lost USB	Risky	OAuth tokens / API keys live in `dat` in plaintext; no remote wipe

claude --dangerously-skip-permissions is intentional. The implicit deal is “the USB is isolated from the host, so giving the AI root inside it is an acceptable trade.” That contract breaks at two points: physical loss of the USB, and outbound network exfiltration. The README points users at the Anthropic console and the OpenAI console to revoke tokens if the USB is lost.

Version history — Alpine to Mint

CHANGELOG.en.md tells a short but informative story.

graph LR
 V1["v1.0.0 <br/> Alpine + console only"] --> V106["v1.0.6 <br/> X11 + Firefox"]
 V106 --> V120["v1.0.20 <br/> Wi-Fi GUI iwgtk"]
 V120 --> V134["v1.0.34 <br/> Ventoy auto-boot"]
 V134 --> V200["v2.0.0 <br/> Mint base"]
 V200 --> V204["v2.0.4 <br/> Codex CLI added"]
 V204 --> V205["v2.0.5 <br/> one window, two tabs"]

v1.0.0 (2026-05-01) — Alpine Linux 3.20, console only, root autologin, just claude-code
v1.0.6 — added X11 + fluxbox + Firefox, becoming a desktop
v1.0.20 — Wi-Fi GUI via iwgtk + iwd, RTL8821CE compatibility
v1.0.34 (2026-05-05) — Ventoy auto-boot, chrony for time sync (fixes 1970-epoch SSL cert failures)
v2.0.0–v2.0.4 — base swapped from Alpine to Linux Mint 21.3, Codex CLI added, renamed to AICODE-OS
v2.0.5 (2026-05-09) — two separate windows collapsed into one window with two tabs (works on 1366×768 screens)

The Alpine-to-Mint swap is interesting. The project started with “smallest possible base” and walked itself into the standard Linux distro pain: as X11, IME, and Wi-Fi driver dependencies stacked up, the maintainer pivoted to a “battle-tested Ubuntu derivative.” The classic minimalism-versus-hardware-compatibility curve.

Where it sits in the Claude Code “distro” landscape

Looking at claude-code-os, a cluster of adjacent projects starts to make sense. They all treat Claude Code as a kernel and layer their own opinion on top.

graph TD
 CC["Claude Code kernel <br/> @anthropic-ai/claude-code"]

 CC --> Distro1["claude-code-os <br/> bootable LiveUSB"]
 CC --> Distro2["SuperClaude_Framework <br/> persona/command framework"]
 CC --> Distro3["awesome-claude-code <br/> curation"]
 CC --> Distro4["agent-skills <br/> workflow forcing skills"]

 Distro1 -. "OS level" .-> Layer1["hardware + Linux"]
 Distro2 -. "config level" .-> Layer2["slash commands + personas"]
 Distro3 -. "discovery level" .-> Layer3["curated links"]
 Distro4 -. "behavior level" .-> Layer4["markdown skill bundles"]

SuperClaude-Org/SuperClaude_Framework (~22.7K stars) — “a configuration framework that enhances Claude Code with specialized commands, cognitive personas, and development methodologies.” Sits on top of an existing Claude Code install; conceptually the “X-windows” layered over the same kernel.
hesreallyhim/awesome-claude-code — the Awesome-list curation: an index of what exists.
anthropics/skills — Anthropic’s own agent-skills bundles. Spawned ports like thedalbee/codex-r that bring the same pattern into the Codex world.
rohitg00/agentmemory — persistent memory shared by 16+ agents over MCP.

What separates claude-code-os from the rest is abstraction level. SuperClaude is a different shell environment on the same OS. claude-code-os swaps the OS itself. As the early Linux distro wars fragmented Debian, Red Hat, and Arch across the same kernel with different package managers and desktops, Claude Code distros are differentiating along similar lines — OS-level, framework-level, skill-level.

Who it is for

The intended persona is clear.

Scenario	Fit	Why
Demos — show AI on anyone’s laptop	High	Plug in, 1 minute, host stays clean
Casual coding on a light laptop	Medium	3.5 GB persistence cap
Onboarding non-engineers to AI	High	Zero OS install friction
Daily-driver dev environment	Low	Personal dotfiles / SSH keys / git config need separate sync
Security-sensitive work	Low	Root AI + plaintext tokens on USB

Best fit: classroom demos, conference booths, onboarding non-technical users. Poor fit: replacing a dotfile-heavy personal workstation.

Interesting design details

One window, two tabs (v2.0.5) — earlier versions opened two separate xfce4-terminal windows with fixed --geometry coordinates. The Codex window was clipped off-screen on 1366×768 displays (e.g. Samsung NT900X3A). v2.0.5 switches to xfce4-terminal --maximize --tab, safe on any resolution.
Graceful exit — when claude or codex exits, the parent shell stays alive via exec bash. Type claude again to relaunch in place.
Stale autostart cleanup — aicode-startup-dual rms leftover ~/.config/autostart/*.desktop files from older v2.0.x revisions, so an upgraded persistence USB does not break.
Why chrony — added in v1.0.34 to fix the 1970-epoch problem. A LiveUSB cannot trust the host RTC, and OAuth / SSL handshakes fail on certificates that look “not yet valid” when the clock is wrong.
D2Coding via wget from Naver’s release — the font is not in Ubuntu repos, so the build pins a specific tag (VER1.3.2-20180524).

Limits and open questions

Persistence dat does not auto-grow — fixed at the size you created it (default 3.5 GB). Hitting the cap means making a larger dat and swapping it in.
FAT32 USBs are unsuitable — single-file 4 GB cap blocks larger dat files. exFAT recommended (Ventoy 1.0.96+ defaults to it).
Reaching host data needs manual mounts — the “zero trace” property is also a wall between the USB world and any code already on the host.
Root AI + full network = user diligence — the README explicitly tells you not to run unknown commands. The security model has a human-in-the-loop assumption baked in.

Conclusion — taking the “OS is AI” tagline seriously

claude-code-os is not another configuration framework layered on top of Claude Code. It is a LiveCD distro that wires the agent into init. If SuperClaude is “a different shell on the same OS,” this is “a different OS entirely.” The branching matches how early Linux distros fragmented from a shared kernel — Debian, Red Hat, Arch each layered their opinion on top — and Claude Code distros now stack opinions at OS, framework, and skill levels above the same npm package.

The interesting next problem is the trade-off between sandboxed isolation and host integration. “Host safe + AI root” is perfect for demo and onboarding, but a daily driver needs your dotfiles, SSH keys, and git config to follow you. For a bootable USB to graduate into “my whole dev environment,” it needs that bridge.

References

claude-code-os itself

Hostingglobal-Tech/claude-code-os — the repo
v2.0.5 release — two-part ISO + persistence dat
CHANGELOG.en.md — Alpine → Mint history
build-mint.sh — the build

Dependencies

Ventoy — multi-ISO bootable USB
Ventoy persistence plugin — casper-rw backend
Linux Mint 21.3 XFCE — base OS
@anthropic-ai/claude-code · @openai/codex — the two agents
Naver D2Coding font

Adjacent Claude Code ecosystem

SuperClaude-Org/SuperClaude_Framework — persona / slash command framework
anthropics/skills — agent-skills from Anthropic
rohitg00/agentmemory — MCP-based persistent memory
thedalbee/codex-r — import Claude Code sessions into Codex
Model Context Protocol