Hiring and team adoption

The first four articles in this track measured the machine: throughput and memory under load, threads against goroutines, Result against if err != nil, and two binaries on a scale. This one measures the other input to the same decision — the people. Which language can a team actually staff, what does the market for each look like right now, and how long is the ramp for someone joining. The answer decides as many stack choices as the benchmarks do, and it is the axis where the folklore is furthest from the numbers.

Two kinds of evidence appear below, kept separate on purpose. First, published numbers with named sources and dates: SlashData’s developer-community estimates and the Stack Overflow 2025 survey (49,000+ respondents across 177 countries, published July 2025). Second, one count run on this machine on October 30, 2026, with the exact command shown so it can be rerun and checked. The code demo comes from rustc 1.99.0 (edition 2024) and go1.27.3, same as the rest of the track.

How many developers are there

The headline number is that the scarcity story has quietly flipped. SlashData’s Q1 2025 estimate of language-community sizes put Rust at 5.1 million developers and Go at 5.0 million — the first quarter Rust was ahead. Rust had added about a million developers per year for four straight years, and the last twelve months measured were the strongest: net growth of 1.1 million, or 26%, with cybersecurity demand and the memory-safety push credited as the drivers. Go’s community is growing too, but more slowly — which means the two pools are now nearly the same size, and the smaller one is not the one most people guess.

Usage among working developers tells the same story at different magnitudes. In the Stack Overflow 2025 survey, 17.4% of professional respondents reported extensive work in Go over the past year, against 14.5% for Rust — close together, and both an order of magnitude behind JavaScript’s 68.9%. The one number where the languages are not close is retention: Rust has topped the survey’s “admired” ranking for years, and the 2025 edition puts it around 72% of current users who want to keep using it. Admired measures something specific — how many people who already chose the language would choose it again — and it is the number that matters for a team wondering whether hired Rust developers will still be writing Rust in two years.

What the job market says

Survey populations measure people; hiring measures openings. Job boards are hard to count cleanly from outside — every aggregator has different listings, and quoting one board’s totals invites an argument with the next board’s. What is consistent across the sources checked while writing this: Go postings outnumber Rust postings several times over in absolute counts, and the sources that report growth rates have Rust’s rising faster — one 2025 analysis of backend postings put it at roughly 38,000 Go listings against 8,500 Rust, with +8% and +35% year-over-year respectively. Directionally: Go is the bigger market today, Rust the faster-growing one.

There is one hiring pool that can be counted honestly from a laptop, because its posts are public and stable in format: Hacker News’s monthly “Ask HN: Who is hiring?” thread. The count below was run on October 30, 2026 against the October 2026 thread (id 49922569, posted October 1), walking every comment including replies and counting comments that mention each language by word:

curl -s 'https://hn.algolia.com/api/v1/items/49922569' -o hiring.json
python3 - <<'EOF'
import json, re
d = json.load(open('hiring.json'))
acc = []
def walk(n):
    for c in n.get('children', []):
        acc.append(re.sub(r'<[^>]+>', ' ', c.get('text') or ''))
        walk(c)
walk(d)
print(len(acc),
      sum(bool(re.search(r'\brust\b', t, re.I)) for t in acc),
      sum(bool(re.search(r'\bgo\b', t, re.I)) for t in acc))
EOF

361 23 36

361 comments; 23 mention Rust; 36 match the word “go”. The Go count is the noisy one — the same word does other jobs — and eyeballing the matches puts about nine of them in phrases like “go-to-market”, leaving roughly 27 genuine language mentions. Nobody in the thread wrote “golang”. So on the one board where both counts are reproducible: 23 Rust posts against about 27 Go posts in the same month. Not parity with the broader market — this thread over-samples startups and infrastructure companies, exactly the shops that hire for Rust — but nowhere near the 4-to-1 gap the boards suggest, and a useful correction to the assumption that Rust jobs are unfindable.

The first month

Onboarding is where the two toolchains make opposite promises, and a two-line diff shows it. The same mutation mistake, first in Rust:

fn main() {
    let attempts = 0;
    attempts += 1;
    println!("attempts: {attempts}");
}

▶Run this in the Rust Playground

$ rustc --edition 2024 bad.rs
error[E0384]: cannot assign twice to immutable variable `attempts`
 --> bad.rs:3:5
  |
2 |     let attempts = 0;
  |         -------- first assignment to `attempts`
3 |     attempts += 1;
  |     ^^^^^^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut attempts = 0;
  |         +++

The same lines in Go compile without a word:

package main

import "fmt"

func main() {
  attempts := 0
  attempts += 1
  fmt.Println("attempts:", attempts)
}

$ go run good.go
attempts: 1

Both behaviors are defensible and the difference is a hiring question, not a correctness one. Rust’s new hire hits a wall of errors in week one — this one is trivial, and E0384 is among the friendliest — but look at what the wall is made of: the diagnostic names the error, points at both assignments, and prints the exact fix. The compiler is the tutorial, and it is available at every hour of the day. Go’s new hire compiles almost everything in week one, ships in week two, and the same class of mistake — a value that should not have changed — surfaces later, at runtime or in code review, where the fix costs more. Rust makes its onboarding cost up-front and legible; Go defers its cost and makes it invisible.

Everything else about month one is a near-tie, which surprises people who remember older language wars. Both toolchains are one download with one build tool (cargo, go). Both ship a formatting standard that ends style debates on day one (rustfmt, gofmt) and a built-in linter (clippy, go vet). The real difference in ramp length is conceptual: a competent backend engineer is productive in Go in days because the language deliberately fits in a head, while Rust asks a new hire to internalize ownership and borrowing before the compiler errors stop feeling like weather. Weeks, not months, for someone who already programs — but weeks is real money, and it lands before the new hire has produced anything.

What teams actually do

The pools hire differently. Go recruiting draws from the enormous backend and DevOps pool — most candidates who have built services in Java, Python, or C# are productive in Go within weeks, so the effective candidate pool is far larger than the 5 million who write Go today. Rust hiring mostly cannot do this at the senior level, which produces the circular problem hiring guides for the language describe candidly: companies want production Rust experience, which barely exists because companies won’t hire without it. The teams that staff Rust successfully mostly train in place — experienced C++, Java, or Go engineers learning on the job — or relax the requirement for application-level roles, which is the explicit advice of Rust consultancies like corrode.dev: test for systems thinking and learning speed instead.

Adoption inside companies is broader than the hiring folklore suggests: the State of Rust 2024 survey (7,310 responses) found 45% of Rust users saying their organization makes non-trivial use of the language. But the jobs concentrate — infrastructure, databases, security-critical components, and increasingly browser and kernel work — while Go postings spread across the whole backend surface. A team hiring four backend developers this quarter has a vastly deeper Go pool to fish in; a team staffing a performance-critical component finds the Rust pool small but motivated, and the retention number from the survey section says the people in it stay.

What the numbers say

measure	Rust	Go	source
developers worldwide (Q1 2025)	5.1 M	5.0 M	SlashData
net growth, prior 12 months	+1.1 M (26%)	positive, slower	SlashData
professional usage (2025)	14.5%	17.4%	Stack Overflow survey
admired by current users (2025)	~72%, ranked first	well behind	Stack Overflow survey
HN “Who is hiring?”, Oct 2026	23 mentions	~27–36 mentions	count run for this article

The hiring axis favors Go on the things a team feels in the first quarter: a deeper effective pool, a shorter ramp, and week-one code that compiles. It favors Rust on the things a team feels in the second year: the people it attracts want to keep writing it, and the supply pipeline is growing faster than any large language’s. Neither number is a reason to pick a language by itself — but the folklore on both sides is wrong. Rust hires are not unfindable, and Go is not the safe choice by default when the deciding factor is headcount; the deciding factor is what the team is building, which is the subject of the final article in this track, the decision table.

Run it yourself

The count above is one command and reruns in seconds — point it at any month’s thread id and the same script gives that month’s numbers:

curl -s 'https://hn.algolia.com/api/v1/items/49922569' -o hiring.json
python3 - <<'EOF'
import json, re
d = json.load(open('hiring.json'))
acc = []
def walk(n):
    for c in n.get('children', []):
        acc.append(re.sub(r'<[^>]+>', ' ', c.get('text') or ''))
        walk(c)
walk(d)
print(len(acc),
      sum(bool(re.search(r'\brust\b', t, re.I)) for t in acc),
      sum(bool(re.search(r'\bgo\b', t, re.I)) for t in acc))
EOF

The two programs are printed in full above: paste the Rust into bad.rs (it refuses to compile, and the diagnostic is the point) and the fixed version with let mut into main.rs under cargo new; the Go file runs with go run good.go. Everything on this page came from rustc 1.99.0 (edition 2024), go1.27.3 darwin/arm64, and public surveys linked by name, as shown.

The track overview has one article left: a decision table that weighs everything this track has measured — performance, concurrency, error handling, deployment, and now people — into a choice that can be defended to the team that has to live with it.