claude-code-dev Skill Review: A Style Guide That Lives Inside Your Agent
2,035 stars on SkillsMP with zero movement in the last week. That's not a red flag — that's a skill that found its audience and settled. The people who need this installed it. The question is whether you're one of them.
Let me save you the time of reading the SKILL.md yourself.
What This Skill Actually Does
The claude-code-dev skill is a structured reference corpus — 14 markdown documents covering the internals of the @anthropic-ai/claude-code codebase — injected into Claude's context so that when you're working on Claude Code itself, the agent already knows the house rules.
We're talking about things like: how imports are structured (.js extensions in ESM, import type for types, cherry-picked lodash), how tools are registered using the buildTool() factory, how state is managed at the module level, how errors are handled with custom classes, and what the formatting rules are (no semicolons, single quotes, trailing commas — yes, it's all documented).
This is not a general-purpose coding skill. It is not trying to teach Claude how to write TypeScript. It is specifically about the Claude Code codebase's conventions, and it makes no apologies for that narrow scope.
Why This Exists and What Problem It Solves
Here's the problem: Claude Code is a non-trivial codebase. It's an ESM TypeScript CLI app using Ink (React for terminals), built with esbuild, with Bun involved for feature flags and dead code elimination. The architecture has opinions — strong ones — about how tools are structured, how commands are registered, how state flows through the app, and how files are named.
If you're contributing to Claude Code, or forking it, or building something adjacent to it, and you just start writing code in your own style, you're going to create inconsistency. You'll use the wrong import pattern. You'll structure a tool differently than every other tool in the codebase. You'll add semicolons. Someone will have to clean it up.
The traditional solution is to read the codebase until you absorb the patterns. That takes hours. This skill compresses that into something Claude can reference on demand.
The gap it fills is real: there's no official contributor guide for Claude Code that covers this level of implementation detail. This skill is filling that void with what appears to be a careful reverse-engineering of the actual source conventions.
Key Capabilities Worth Highlighting
1. Tool Architecture Documentation (Guide 09)
This is the most practically useful section. The buildTool() factory is the entry point for every tool in Claude Code, and getting its API wrong means your tool doesn't integrate cleanly. The guide covers the full structure: schemas, permissions, UI rendering. If you're adding a tool, you read this first.
2. Import Conventions (Guide 03)
ESM with .js extensions is a common stumbling block. The guide covers the full import discipline: when to use import type, how lodash cherry-picks work, how feature flags are imported, and how circular dependency cycles are broken. This alone is worth having in context when you're adding a new module.
3. TypeScript Patterns (Guide 05)
Branded types, discriminated unions, as const, satisfies, Zod v4 schemas — the guide documents the specific TypeScript idioms the codebase uses. This is useful because these patterns are consistent across the codebase and Claude will match them if it knows about them.
4. Quick Reference Checklists (Guide 14)
Step-by-step checklists for adding tools, commands, utils, and types. This is the pragmatic payoff — not just "here's the philosophy" but "here are the actual steps." When I'm in the middle of a task and need to add a new command, I don't want to read 13 documents. I want the checklist.
5. State Management Patterns (Guide 11)
Module-level state with getter/setter patterns and a cleanup registry is a specific architectural choice that's easy to get wrong if you don't know it's the pattern. This guide documents it explicitly so Claude doesn't reach for React state or some other pattern that doesn't fit.
Who Should Install This
Install it if: - You are actively contributing to the Claude Code source code - You're forking Claude Code and want to maintain stylistic consistency with upstream - You're building tooling that wraps or extends Claude Code and need to understand its internals - You're doing code review on Claude Code contributions and want a reference - You're onboarding to the codebase and want to accelerate the ramp-up
Don't install it if: - You're using Claude Code as an end user and have no interest in its internals - You're building a completely separate project that happens to use TypeScript - You're looking for a general TypeScript or Ink style guide (this is too specific) - You have tight context window constraints and can't afford the overhead of 14 reference documents
The skill is narrow by design. That's a feature. Don't install it if it doesn't match your use case — it'll just burn context for no reason.
How to Install
Standard skill installation. Drop it into your skills directory:
# Global install
mkdir -p ~/.claude/skills
cd ~/.claude/skills
git clone https://github.com/chatgptprojects/clear-code.git
# The skill lives at clear-code/claude-code-skills/
Or if you want it project-local:
mkdir -p .claude/skills
# Copy or symlink the claude-code-skills directory there
The skill's description is specific enough that Claude should activate it automatically when you're working on Claude Code source. If it doesn't, you can reference it explicitly in your prompt.
Honest Concerns and Limitations
I have a few issues worth naming.
The provenance is unclear. This skill is authored by chatgptprojects and lives in a repo called clear-code that is primarily a curated list of open-source AI coding tools — with a monetized AI gateway product prominently featured in the README. The skill itself seems well-researched, but it's not an official Anthropic document. It's someone's reverse-engineering of the Claude Code codebase. That means it could be wrong, incomplete, or out of date.
Staleness is a real risk. Claude Code ships fast. The codebase evolves. A style guide that was accurate six months ago may not reflect current patterns. There's no clear versioning or update cadence documented for this skill. If you're relying on it for architectural decisions, verify against the actual source.
Context cost. Fourteen markdown documents is a non-trivial context load. If you're working on a task that only touches one area of the codebase, you're paying for 13 documents you don't need. The skill doesn't appear to have a lazy-loading mechanism — it's all or nothing.
The repo's primary purpose is not this skill. The clear-code repo is a community resource hub with a commercial angle (the LeanMCP AI gateway product). The skill is one artifact in a larger project. That's not disqualifying, but it means maintenance priorities might not be centered on keeping this skill accurate.
No tests or validation. There's no way to verify that the documented patterns actually match the current codebase without manually checking. For a skill that's specifically about code correctness and style matching, that's a gap.
Verdict
If you're working on Claude Code source, install it. The content is well-organized, the scope is appropriate, and having this reference in Claude's context is genuinely better than not having it. The 14-document structure is a smart way to organize deep reference material, and the quick-reference checklists in Guide 14 are the kind of thing that saves real time.
Just don't treat it as authoritative without cross-checking against the actual source. It's a community-maintained reverse-engineering, not official documentation. Use it as a starting point, not a final word.
For everyone else — the 90% of Claude Code users who are using it as a tool rather than hacking on it — skip it. It's not for you, and the context overhead isn't worth it.
Rating: Recommended with caveats — solid for its target audience, but verify freshness before trusting it for architectural decisions.
Links: - SkillsMP page - GitHub source