24 skills · category

Languages skills for Claude Code

Skills that make Claude write code a language community would recognise as idiomatic: strict TypeScript, modern Python with uv and ruff, Rust ownership, Go concurrency, Java 21, Kotlin coroutines, Swift 6 concurrency, C#, PHP, Ruby, Elixir, robust Bash, and regular expressions that do not backtrack catastrophically.

Download all 24 (.zip) Browse the list

Every languages skill

Each card opens the full playbook, example prompts and install commands.

No. 101

Bash Scripting

Shell scripts that fail loudly and clean up after

Claude starts every script from a hardened template with set -Eeuo pipefail, an ERR trap that names the failing line, temp-dir cleanup, getopts parsing and a dry-run mode. It knows where set -e silently does nothing, builds commands as arrays instead of strings, guards destructive steps against empty variables, and says when a task should be Python instead.

bash-scripting 194 lines · 2 files

No. 102

C Systems Programming

C that carries its buffer sizes and frees on every path

Claude writes C where every buffer travels with its capacity, size arithmetic is overflow-checked, and each function has one cleanup path that frees whatever it acquired. It designs opaque-handle library APIs with documented ownership, applies strict warning and hardening flags, scans for strcpy-class calls with a bundled script, and verifies with sanitizers and Valgrind.

c-systems 224 lines · 2 files

★ No. 103

Modern C++

C++20/23 with clear owners and sanitizer-clean tests

Claude writes C++ where signatures say who owns what, resources die in destructors, and views never outlive their containers. It checks which C++23 features your actual compilers and standard library support before using them, sets up target-based CMake with presets and strict warnings, and proves changes with AddressSanitizer, UBSan, TSan and clang-tidy instead of hoping.

cpp-modern 257 lines · 2 files

No. 104

C# and .NET

Nullable-clean, cancellable, typed .NET code

Claude sets up .NET solutions with Directory.Build.props, central package versions, nullable reference types and warnings as errors, then writes code that threads a CancellationToken through every async call and never blocks on .Result. Endpoints use minimal APIs with typed result unions and route groups, and EF Core reads are projected and untracked.

csharp-dotnet 218 lines

No. 105

Dart Language

Sealed states, exhaustive switches, no bang operators

Claude checks the SDK floor in pubspec.yaml before using records, dot shorthands, or other gated syntax, then models domain states as sealed hierarchies matched by exhaustive switch expressions. It replaces bang operators with flow analysis and patterns, moves CPU-heavy work into Isolate.run, enables strict analyzer modes and future lints, and proves lower bounds with pub downgrade.

dart-language 269 lines

No. 106

Elixir and OTP

Processes for state and failure, not for code

Claude first asks whether a process is needed at all, then writes GenServers with fast init via handle_continue, catch-all handle_info clauses and clean client APIs. It builds supervision trees with deliberate strategies and restart types, uses Registry and DynamicSupervisor for per-entity processes, ETS for hot reads, and keeps Phoenix code behind contexts.

elixir-otp 215 lines

No. 107

Go Idioms

Go that passes review on the first round

Claude writes Go the way experienced Go reviewers expect: consumer-side interfaces, errors wrapped with context and checked via errors.Is and errors.As, generics only where they remove real duplication, and goroutines that always have an exit path through context and errgroup. Tests are table-driven and every change is checked with vet, staticcheck and the race detector.

go-idioms 232 lines

No. 108

Haskell Functional

Total functions, typed domains, and leak-free IO

Claude writes the type signature first, models domains with sum types, strict fields and smart constructors, and replaces head, fromJust and read with total alternatives. It keeps a pure core under a ReaderT-over-IO shell, reads GHC errors one at a time with a decoded catalog, fixes space leaks with foldl' and strict maps, and gates builds on -Wall, hlint, hspec and QuickCheck.

haskell-functional 244 lines · 2 files

No. 109

Modern Java

Records, sealed types, and virtual threads done right

Claude writes Java that uses what the language finally offers: immutable records with compact-constructor validation, sealed hierarchies matched by exhaustive switch with record patterns and no default branch, and virtual threads for blocking I/O with semaphores instead of pools. It upgrades legacy 8, 11 and 17 codebases in a safe order, build tooling first.

java-modern 191 lines

No. 110

Julia Scientific Computing

Type-stable Julia, measured before and after

Claude writes Julia kernels in functions with concrete types, then proves they are fast with BenchmarkTools, @code_warntype and JET instead of trusting the language's reputation. Projects get their own Project.toml and Manifest.toml, DataFrames work uses transform and combine rather than row loops, and first-call latency is handled with PrecompileTools or a sysimage when users feel it.

julia-scientific 236 lines · 2 files

No. 111

Kotlin Idioms

No !!, no GlobalScope, no leaked coroutines

Claude writes Kotlin that resolves nulls at the edge, models screens and results as sealed types with exhaustive when, and launches every coroutine in a scope something owns. It picks Flow, StateFlow, SharedFlow or Channel deliberately, keeps suspend functions main-safe, rethrows CancellationException, and tests timing with virtual time instead of sleeps.

kotlin-idioms 218 lines

No. 112

Lua Scripting

Lua for Neovim, Redis and game hosts, minus the globals

Claude first pins down which Lua it is writing for (LuaJIT in Neovim, 5.1 in Redis, Luau in Roblox, 5.4 or 5.5 standalone) and avoids syntax the host cannot run. It keeps every variable local, uses one shape per table, builds classes with __index, passes Redis keys through KEYS for cluster safety, and catches errors with pcall at the host boundary.

lua-scripting 258 lines

No. 113

Modern PHP

Typed, enum-driven PHP that PHPStan trusts

Claude writes PHP with strict_types in every file, full type coverage, backed enums matched exhaustively, and readonly value objects instead of loose arrays. It adopts PHPStan with a baseline that only shrinks, uses Rector for mechanical version upgrades in their own commits, and turns on Laravel's strict model mode so lazy loading and silent attribute drops fail loudly in development.

php-modern 211 lines

No. 114

PowerShell Scripting

Object pipelines that stop on errors and honor -WhatIf

Claude writes PowerShell that passes objects instead of formatted text, uses CmdletBinding with validated parameters and pipeline input, and makes failures stop the script, including native commands such as git and az. Destructive work goes through ShouldProcess and a -WhatIf dry run first, modules export explicit function lists, and PSScriptAnalyzer and Pester gate every change.

powershell-scripting 257 lines · 2 files

No. 115

Modern Python

uv, ruff, strict types, one pyproject.toml

Claude builds Python projects the 2025 way: uv manages interpreters, venvs and the lockfile, dev tools live in dependency groups, ruff replaces black, isort and flake8, and new code ships with strict type hints using 3.12 generics. It migrates requirements.txt, poetry or setup.py projects without breaking installs and knows when to reach for dataclasses versus Pydantic.

python-modern 220 lines · 2 files

No. 116

R Tidyverse

Pipelines with predictable row counts and real plots

Claude reads data with explicit column types, predicts the row count of every dplyr step, and guards joins with relationship and unmatched checks so duplicates fail loudly. It writes tidy-eval functions with {{ }}, plots that state a finding with fixed export sizes, Quarto reports that render from a clean session, and keeps package versions pinned in renv.lock.

r-tidyverse 291 lines · 2 files

No. 117

Regex Crafting

Patterns with test cases and no ReDoS surprises

Claude writes regexes test-first: a cases file of must-match, must-not-match and expected captures, then the simplest anchored pattern that passes. It knows where PCRE, JavaScript, Python, Java, Go and grep disagree, rewrites nested quantifiers and overlapping alternations, and runs a bundled script that pumps inputs to expose catastrophic backtracking before it ships.

regex-crafting 184 lines · 2 files

No. 118

Ruby Idioms

Enumerable over loops, small objects, clean Bundler

Claude writes Ruby that a seasoned Rubyist would merge: filter_map, tally and each_with_object instead of index loops and mutated arrays, Data.define value objects, pattern matching for nested JSON, and modules chosen deliberately between include, extend and prepend. It keeps Bundler locks portable across platforms and adopts RuboCop with a todo file that only shrinks.

ruby-idioms 213 lines

No. 119

Rust Ownership

Satisfy the borrow checker without clone spam

Claude reads rustc's three spans, finds where a borrow can end sooner or a value can have a single owner, and fixes errors structurally instead of cloning or wrapping everything in Rc<RefCell>. It applies the thiserror-for-libraries, anyhow-for-binaries split, sets up edition 2024 workspaces with shared lints, and keeps clippy at zero warnings.

rust-ownership 201 lines · 2 files

No. 120

Scala 3 Functional

Exhaustive ADTs, typed errors and one effect system

Claude models domains with Scala 3 enums, opaque types and validated constructors so bad states fail to compile, keeps errors as values until the program edge, and picks Cats Effect or ZIO to match the codebase instead of mixing them. It turns on strict scalacOptions, places givens where they resolve without imports, and respects the 3.3 and 3.9 LTS split for libraries.

scala-functional 242 lines

No. 121

Swift Concurrency

Reach Swift 6 mode with zero data-race warnings

Claude migrates Swift code to strict concurrency one module at a time, reading each isolation diagnostic for its real cause instead of reaching for @unchecked Sendable. It isolates UI models to MainActor, puts shared state in actors or a Mutex, replaces completion handlers with checked continuations, and understands how Swift 6.2 default isolation changes the rules.

swift-concurrency 211 lines

No. 122

TypeScript Strict

Make impossible states fail to compile

Claude migrates and writes TypeScript with the strict family plus noUncheckedIndexedAccess and exactOptionalPropertyTypes, one flag at a time with an error count that only goes down. It narrows instead of casting, validates external data from unknown, models state as tagged unions with never checks, and backs public types with compile-time tests.

typescript-strict 253 lines

No. 123

WebAssembly Modules

Ship wasm only where it pays, and keep it small

Claude first checks whether WebAssembly will actually beat JavaScript for the job, then picks the matching target: wasm-bindgen, Emscripten, wasip1 or wasip2 components. It designs coarse JS boundaries that survive memory growth, loads modules in workers with correct headers, and uses a bundled analyzer to find the largest sections and functions and enforce a gzip size budget.

webassembly-modules 218 lines · 2 files

No. 124

Zig Programming

Zig for your pinned compiler, not last year's stdlib

Claude checks zig version before writing anything, because each Zig release rewrites parts of the standard library. It then passes allocators and the 0.16 Io interface explicitly, pairs every allocation with defer or errdefer, handles error sets exhaustively, keeps comptime generics simple, and wires build.zig modules, zig fetch dependencies and C libraries correctly.

zig-programming 277 lines

Choosing Languages skills

Install the skills that match requests you make every week; each costs about 100 tokens of standing context until it loads. If you are not sure where to begin, start with Modern C++. For background, read The Best Claude Code Skills in 2026, by Use Case, How to Install Claude Code Skills (5 Ways) and Personal vs Project Skills.

By technology: Python skills Rust skills Java and Kotlin on the JVM skills

Install several

Install several at once

The installer accepts any number of skill names. Add --project to install into the current repository.

curl -fsSL https://claudeskills.page/install.sh | sh -s -- bash-scripting c-systems cpp-modern csharp-dotnet dart-language elixir-otp go-idioms haskell-functional java-modern julia-scientific kotlin-idioms lua-scripting php-modern powershell-scripting python-modern r-tidyverse regex-crafting ruby-idioms rust-ownership scala-functional swift-concurrency typescript-strict webassembly-modules zig-programming

Languages skills FAQ

How do I install every Languages skill at once?

Download the bundle at https://claudeskills.page/downloads/category/languages.zip and unzip it into ~/.claude/skills/ (or .claude/skills/ inside a repository). To pick a few, pass several names to the installer: curl -fsSL https://claudeskills.page/install.sh | sh -s -- bash-scripting c-systems cpp-modern.

Will installing 24 skills slow Claude Code down?

No. Claude Code keeps only each skill's short description in context — roughly 100 tokens per skill — and loads the full instructions only when a request matches. Install the whole category if it fits your work; unused skills cost almost nothing.

Which Languages skill should I start with?

Start with Modern C++. They cover the most common requests in this category; add the rest as your work calls for them.