Language selection

Skill GhostlyGawd/recursive-harness/skills/language-selection

Portable, evidence-driven agent development harness for Codex, Claude Code, and generic Agent Skills. Active beta v0.1.2.

Install

npx -y skills add GhostlyGawd/recursive-harness --skill language-selection

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

3 stars3 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Catalog + decision procedure for choosing a programming language. TRIGGER whenever you are about to pick, default, recommend, or assume a language for new work — a greenfield project/service/script/CLI/library, a component in a polyglot system, a rewrite or port, or when a user asks "what should I build this in". Also when weighing two stacks, or judging whether an existing language still fits a new requirement. Don't default to Python/JS from habit: consult the catalog (references/index.md) so the pick is matched to domain, hard constraints, stack, and ecosystem — with tradeoffs stated.

SKILL.md

7.8 KB, as published. Nobody here has run it

Language Selection

This skill exists to push a language choice past your default priors. Picking a language is a consequential, hard-to-reverse decision — it sets the deploy target, the performance ceiling, the libraries within reach, and the failure modes you live with. Reason from the task's actual requirements instead of reaching for whatever language is most probable by default (Python, JavaScript), then consult the catalog in references/index.md to weigh those requirements against the full field before you commit.

The procedure

Surface HARD constraints first — these eliminate candidates; they do not trade off. Read these off the task itself, before any candidate language anchors your thinking:
- Target/runtime: browser → JS/TS (or a WASM-source lang); iOS → Swift; no-GC / hard-real-time / tiny footprint → C / C++ / Rust / Zig; an existing JVM or .NET shop; serverless cold-start ceilings.
- Interop / FFI: must it call into existing C, Java, .NET, or Python?
- Performance floor: are GC pauses or a memory ceiling actually disqualifying, or just assumed to be? Demand a number before letting this drive the choice.
- Certification / safety: safety-critical → Ada/SPARK, MISRA-C, DO-178C lanes.
Surface SOFT factors — these trade off, weighted to THIS project:
- Existing codebase / current stack. Reusing what's already in place — its build, deploy, and libraries — usually beats adding a second language; weigh it unless a hard constraint forbids.
- Ecosystem maturity for this domain. The right library beats language elegance; a missing one sinks an elegant choice.
- Iteration speed vs runtime performance for the project's current phase.
- Long-term maintainability and readability of the result.
Build the candidate set from those requirements — consult references/index.md and assemble candidates from what actually fits, not from what comes to mind first. The index is the source of truth; reason over it rather than recalling a usual answer. (The quick table below is a fast starting point for common cases — candidates to verify, not answers.)
Intersect candidates with the hard constraints → shortlist 2–3.
Break ties with soft factors. Recommend ONE. Name the runner-up. State explicitly what you trade away and the condition under which the runner-up wins.
If the user already named a language, your job is fit-check, not override: confirm it clears the hard constraints, flag genuine mismatches with evidence, and do not relitigate taste.

Falsifiable rules (the habits this skill exists to break)

Don't reach for the language that's merely most probable by default. Fitting an existing codebase IS a legitimate SOFT factor — name it as one; don't dress a default up as a domain match.
Fitting an existing codebase usually beats a greenfield-optimal pick unless a hard constraint forbids it — introducing a new language carries real, front-loaded cost (build, deploy, interop).
"Rewrite it in Rust/Go" needs a hard-constraint justification (perf floor, memory safety, deploy target) — not aesthetics. A rewrite discards working code and the edge-case knowledge baked into it.
Prefer boring/proven for load-bearing systems. Reserve emerging languages (Zig, Mojo, Gleam, Roc) for where their specific edge IS the point and you can absorb the ecosystem gaps.
Every added language in a polyglot system is a tax: build/CI, interop, context-switching. Justify each one; "right tool for the job" is not a free pass.
Performance intuition is unreliable. A "slow" language with the right library (NumPy, the JVM JIT, V8) often beats a hand-rolled fast-language path. Measure the hot path; don't pick the whole stack to optimize a path that isn't hot.

Quick domain → candidates (the common 80%)

A fast starting point for common cases — entries are candidates to verify against your requirements and the catalog, never defaults to settle for. The genuinely forced cases (browser → JS/TS, iOS → Swift) are hard constraints, already in step 1.

Domain / task	Lead candidates	Also consider
Systems / OS / embedded / no-GC	Rust, C	C++, Zig, Ada (safety)
CLI tools / dev tooling	Go, Rust	Python (quick), TypeScript (Node)
Backend web service / REST/gRPC API	Go, TypeScript, Java/Kotlin	C#, Python, Elixir, Ruby
Very high concurrency / soft-real-time	Elixir/Erlang, Go	Rust, Java (virtual threads)
Web frontend (browser UI)	TypeScript	(WASM source: Rust, C++)
ML / data science / AI	Python	R (stats), Julia (numerical)
Data engineering / ETL / big data	Python, SQL	Scala/Java (Spark), Go
Scientific / HPC / numerics	C++, Julia, Fortran	Python+native, CUDA C++ (GPU)
Scripting / automation / glue	Python, Bash	PowerShell (Windows), Ruby
iOS / macOS	Swift	Objective-C (legacy interop)
Android	Kotlin	Java (legacy)
Cross-platform mobile	Dart/Flutter, TS/React Native	Kotlin Multiplatform
Game engine / real-time graphics	C++, C# (Unity)	Rust (emerging), Lua (scripting)
Enterprise / large team / long-lived	Java, C#	Kotlin, Go
Correctness-critical / heavy domain logic	OCaml, F#, Haskell	Scala, Rust, Elixir
Smart contracts	Solidity (EVM)	Move (Aptos/Sui), Rust (Solana)
Quick data analysis / notebooks	Python (pandas)	R, Julia

Full catalog

references/index.md — the language repository: ~45 languages grouped by family (systems, managed-runtime backend, frontend, data/ML/scientific, functional, mobile, scripting/shell, emerging, and domain-specific), each with a card covering paradigm, typing, runtime, concurrency model, performance tier, killer ecosystem, best-fit domains, and explicit pick-when / avoid-when. It is the source of truth the quick table only summarizes — open the relevant family every time you build a candidate set (step 3), not only for unfamiliar domains or niche targets. The families exist so you can scan the whole relevant field, not just the names that came to mind.