Best Language Skills for Claude Code (2026)

TL;DR + decision tree

• Mobile cross-platform? flutter-development. Highest-trafficked language skill on the directory (1,111 page views, 319 GSC monthly impressions across "flutter skills" variants).
• Idiomatic Go? effective-go by openshift. Concurrency-aware, opinionated, follows the Go team's style guide.
• Memory-safe systems work? rust-coding-skill. Ownership, lifetimes, async/await, error handling patterns.
• Android with Compose? android-kotlin-development. Material 3 patterns, Jetpack Compose, view-model lifecycle.
• Strict TypeScript? typescript-best-practices. Strict-mode patterns, type-safe utilities, no any-creep.

Install all five if you switch contexts; the activation system handles routing. Pick the canonical skill per language to avoid two same-language skills firing at the same time. Skip the sub-language extras (e.g. react-flow-node-ts, nextjs-app-router-patterns) until you're actually working in that sub-stack — they're narrow and don't replace the canonical TypeScript skill.

What language skills do

A Claude Code skill is a folder with a SKILL.md file at the root. The frontmatter describes when the skill should activate. The body is the instructions Claude reads after activation. For language skills the instructions are usually a condensed style guide: idiomatic patterns, anti-patterns to avoid, the language's standard library you'd expect a senior engineer to reach for first.

That's different from an MCP server. An MCP server exposes callable tools — compile(), run_tests(), list_files(). A skill doesn't add tools; it changes the cognitive baseline. When a Flutter skill fires, the agent doesn't gain new capabilities; it stops writing JavaScript-shaped Flutter and starts writing Flutter-shaped Flutter. That distinction is the main reason language skills win over "language MCP servers" that wrap a CLI: the bottleneck is the model writing idiomatic code, not the model invoking flutter analyze.

The five skills below are the canonical pick per language by GSC traffic and on-directory page views. Each section follows the same structure: card → what it does best → when to pick → a copy-pasteable recipe → when to skip.

Side-by-side matrix

License + author verified from each skill's repository as of May 2026. The matrix is what changes per language; the installation command is identical across all five (the directory's standard skill install path).

Flutter — install + recipe

What it does best

Flutter-development is the highest-trafficked language skill on the directory by GSC volume — the "flutter skills" cluster lands 319 monthly impressions across variants like "flutter skills claude code" (12% CTR at position 6) and "claude flutter skill" (13% CTR at position 5). The skill activates on Flutter or Dart prompts and shifts the agent into widget-tree thinking: stateful vs stateless choice, Material 3 vs Cupertino, Riverpod / BLoC / Provider for state management, platform channels for native interop. Without it, Claude tends to write React-shaped Flutter. With it, the composition feels native.

Pick this if you...

• Ship to iOS + Android + web from a single codebase
• Use Riverpod, BLoC, or Provider and want the agent to follow your chosen pattern
• Need Material 3 or Cupertino-correct widgets for App Store / Play Store review
• Are migrating from React Native and need the agent to stop reaching for JSX

Recipe: build a Riverpod-backed login flow

Prompt: Build a login screen in Flutter using Riverpod for state. Include email + password fields with validation, a loading state during the API call, error display, and a route to /home on success. Use Material 3 components and follow the flutter-development skill conventions. The agent will generate a login_screen.dart with a StateNotifierProvider for the form state, a FutureProvider.autoDispose for the API call, and a ConsumerWidget at the screen level. Validation runs in the notifier, not the widget. The skill prevents the agent from putting setState in a Consumer (a common React-shaped mistake).

Skip it if...

You're writing a one-off plain-Dart CLI script (the skill pulls in Flutter conventions you don't need) or you ship exclusively to native iOS / Android — for those, the android-kotlin-development skill plus a future iOS-Swift skill will fit better than a cross-platform abstraction.

Go — install + recipe

What it does best

Effective-go is published by openshift — a team that ships production Go at scale — and the skill is shaped by that. It pushes the agent toward the Go style guide: short receiver names, errors as values, table-driven tests, no exceptions, no generics where interfaces work. The GSC cluster around "golang skill" / "golang skills claude" / "claude golang skills" lands 200+ monthly impressions at consistent 5-8% CTR around position 5-6. The skill is particularly strong on concurrency: it stops the agent from writing nested goroutines that leak when the parent returns.

Pick this if you...

• Ship server-side Go (microservices, gRPC, HTTP APIs)
• Care about idiomatic error handling — wrapping vs sentinels vs errors.Is
• Use goroutines + channels and want correct cancellation / context propagation
• Run linters (staticcheck, revive, golangci-lint) in CI

Recipe: refactor a buggy worker pool

Prompt: Here's a worker pool that hangs on shutdown. Refactor it to use context.WithCancel for cancellation, sync.WaitGroup for graceful drain, and a buffered job channel sized at numWorkers * 2. Follow effective-go conventions and add a table-driven test for the shutdown path. The skill drives the agent toward the canonical pattern: accept a context.Context as the first parameter, emit errors via a return rather than a panic, drain the channel explicitly before returning. Without the skill, the agent tends to write Java-shaped Go with sync.Mutex everywhere.

Skip it if...

You're writing protocol buffers without business logic (the skill is opinionated about logic; protobuf code is generated and conventions don't apply) or you're on Go 1.18-1.20 generics-heavy code — effective-go pushes against generics where interfaces would be cleaner, which is the right call for most code but wrong for libraries explicitly designed around type parameters.

Rust — install + recipe

What it does best

The Rust skill is the right call when the agent needs to reason about ownership before writing code. Without it, Claude tends to write Rust as if it were Go — String everywhere, no &str, allocate on every function. With the skill, the agent leads with borrowed references, picks Box<dyn Trait> only when it actually needs heap dispatch, and reaches for Result<T, E> + the ? operator instead of match everywhere. GSC for "rust skills" runs ~71 monthly impressions at 4% CTR position 9 — the cluster is smaller than Flutter or Go, but the per-query intent is high (people searching specifically for a Rust skill are committing to Rust).

Pick this if you...

• Write Rust that compiles in CI without 30 borrow-checker rounds
• Use async/await with tokio or async-std and need correct Send / Sync reasoning
• Mix unsafe FFI with safe wrappers and need the agent to audit the safety invariants
• Care about thiserror vs anyhow conventions per your crate's public surface

Recipe: convert callback-style code to async

Prompt: Here's a callback-style HTTP client wrapper. Convert it to async/await using tokio, return Result<Response, ClientError> with a custom thiserror enum, and ensure all borrows live long enough across .await points. Add unit tests with mock_server. The skill keeps the agent from sprinkling .clone() to silence the borrow checker; instead it suggests the right lifetime annotation or restructures to take ownership at the boundary. The error type is a custom enum, not Box<dyn Error> — better for callers, harder for the model to get right without the skill.

Skip it if...

You're writing a one-off prototype where compile time matters less than getting a working draft (the skill pushes for idiomatic patterns that occasionally fight the compiler harder than ad-hoc code) or you're calling into a C library with a thin FFI wrapper — the skill assumes you're writing application Rust, not bindings.

Kotlin / Android — install + recipe

What it does best

Android-kotlin-development is the canonical skill for native Android work in 2026 — Jetpack Compose for UI, Coroutines + Flow for async, Hilt for DI, Room for SQLite, and the ViewModel + StateFlow patterns Google has standardized on. The skill is published by aj-geddes (the same author behind flutter-development), so the conventions feel coherent if you cross between cross-platform Flutter and native Android within the same project.

Pick this if you...

• Build native Android (not Flutter or React Native)
• Use Jetpack Compose and want the agent to write composables with correct recomposition behavior
• Migrate legacy XML layouts to Compose without losing functionality
• Need Hilt + Room patterns that match Google's sample apps

Recipe: convert XML layout to Compose

Prompt: Convert this RecyclerView + Adapter setup to a LazyColumn in Jetpack Compose. Use a data class for the row model, hoist state to a ViewModel with StateFlow, handle pull-to-refresh with PullRefreshIndicator, and add a unit test for the ViewModel using Turbine. The skill drives the agent away from the common Adapter-shaped Compose mistake (recomposing the entire list on every item change) and toward keyed composables with stable hashes. The ViewModel exposes StateFlow<UiState> where UiState is a sealed interface, not a nullable bag of fields.

Skip it if...

You're writing pure Kotlin server-side (Ktor, Spring Boot with Kotlin) — the skill is Android-shaped and assumes lifecycle-aware components, which don't exist on the server. For server Kotlin, a generic kotlin-best-practices-style skill would fit; in practice the effective-go conventions translate well to Kotlin server work via the agent without a Kotlin-specific skill.

TypeScript — install + recipe

What it does best

Typescript-best-practices is the strict-mode-by-default option — it pushes the agent away from any, encourages unknown + narrowing at boundaries, leans on satisfies over assertions, and uses utility types (Pick, Omit, Awaited, ReturnType) where most agents would inline interfaces. The GSC query "typescript best practices skill" lands 18 impressions at 11% CTR position 5 — small cluster, high intent. Pair it with a stack-specific skill (nextjs-app-router-patterns, react-flow-node-ts) when working in a specific framework.

Pick this if you...

• Run with strict: true in tsconfig
• Care about discriminated unions, exhaustive switch, and type-narrowing patterns
• Use generics for utility functions and want the agent to pick the right constraint (extends vs no constraint)
• Maintain a public API where types are part of the contract (libraries, SDK packages)

Recipe: type a generic Result helper

Prompt: Write a Result<T, E> helper similar to Rust's Result type. Include map, mapErr, andThen, unwrapOr, and match methods. Use discriminated unions for the success / error variants. Add a tryCatch helper that wraps a Promise into Result<T, Error>. Follow typescript-best-practices conventions. The skill drives the agent to use { ok: true; value: T } | { ok: false; error: E } as the discriminator (not a class with a tag string) and to make match exhaustive via the never check. The tryCatch helper handles unknown thrown values via error instanceof Error ? error : new Error(String(error)), which most agents skip without the skill.

Skip it if...

You ship a JavaScript-first codebase that uses TypeScript only for editor IntelliSense (the skill assumes strict-mode and the conventions feel heavy in non-strict code) or you work primarily in a framework where the framework's skill (nextjs-app-router-patterns, react-flow-node-ts) covers the same conventions in a more specific way.

Common pitfalls

• Two same-language skills installed. Activating both typescript-best-practices and typescript-write means the agent has to merge conflicting guidance and may pick neither. Uninstall one.
• The skill description doesn't name the language. A skill described as "cross-platform mobile patterns" won't fire on a "help me write Flutter" prompt. Edit the SKILL.md description to lead with the language name.
• Skill installed at the wrong scope. Project-scoped skills only fire inside that project; global skills fire everywhere. Mixing the two leads to surprising activations. The convention: language skills go global, project-style skills (codebase architecture, internal conventions) go project-scoped.
• Reference docs not loaded. Skills can include a references/ folder the agent loads on demand. If the SKILL.md doesn't mention the reference docs by filename, the agent never opens them. Add explicit pointers like "See references/concurrency.md for goroutine patterns."
• Trying to use a skill as an MCP server. Skills don't add tools. If you need the agent to run cargo build or flutter analyze, install an MCP server for that — the skill helps the agent write the code but doesn't execute it.

Community signal

The GSC pattern across these five skills is consistent: people search for "{language} skill" or "{language} skills claude" and convert at 5-15% CTR when they land on the right canonical page. Flutter and Go lead the pack on aggregate impressions; Rust and Kotlin trail but with higher per-query intent. TypeScript queries fan out across sub-stack skills (Next.js, React, type-utility patterns) rather than concentrating on a single canonical TypeScript skill — which is why we lead the recommendation with typescript-best-practices but note the sub-stack options.

On r/ClaudeAI, the recurring question is "which skill do I install first?" The honest answer for language skills: start with the language you spend the most time in, install its canonical skill, write a real feature with it, and judge quality of the output before installing more. Skills compound — the second one you add is half as valuable as the first if you're still in the same language; the second one in a different language is fully additive.

Frequently asked questions

Sources

• Skill page views and GSC data: Research/gsc/Queries.csv, Research/gsc/Pages.csv (mcp.directory internal, May 2026)
• Each skill's SKILL.md + repository (linked from /skills): aj-geddes/flutter-development, openshift/effective-go, UtakataKyosui/rust-coding-skill, aj-geddes/android-kotlin-development, HoangNguyen0403/typescript-best-practices
• Anthropic Skills 2.0 spec — the SKILL.md frontmatter format and activation rules
• /blog/why-your-claude-skill-isnt-activating-2026-fixes — the activation pipeline and 8 silent-fail modes
• /blog/cross-agent-skills-cursor-codex-cline-antigravity-gemini-mastra-portability — which agents read SKILL.md natively

Keep reading

• Claude Code Skills: The Developer Guide — what skills are and how the activation pipeline works.
• Claude Flutter skill: 10 apps you can ship today — the Flutter skill cookbook (deeper than this comparison).
• Why your Claude skill isn't activating (2026) — debug the most common activation failures.
• Browse all skills on mcp.directory.