How to Read a Trend

For every trend, ask four questions before spending time on it:

  1. Is it deployed anywhere real? Production use at several organisations counts; demos and keynotes do not.
  2. What problem does it remove for us? If you cannot name one, it is a hobby, which is fine, but budget it as one.
  3. What is the cheapest experiment? Anything that needs a six-month commitment before you learn anything is a bad first step.
  4. What happens if we wait a year? For most trends, very little. For a few (security migrations with long data lifetimes), waiting is expensive.

The Radar

TrendStatus (our judgement)First experiment
Agentic software engineeringAdopt: already changing daily workOne repo, a context file, tests as guardrails, human review of every merge
Pod-based team structureAdopt where teams are large or slowReorganise one product area into a long-lived cross-functional pod
Platform engineering and golden pathsAdopt graduallyOne paved path for the most common service type
Ephemeral preview environmentsAdopt if you deploy to KubernetesA namespace per pull request with automatic cleanup
Post-quantum cryptographyStart now for long-lived dataInventory, then hybrid key exchange on the edge
Agent protocols (MCP, A2A)Adopt MCP; watch agent-to-agent standardsExpose one internal tool as an MCP server
Small and on-device modelsPilot for privacy or latency needsRun a small model locally for one narrow task
WebAssembly beyond the browserPilot: plugins and edge, still maturingA sandboxed plugin system for one extension point
Confidential computingPilot where regulation demands itA single sensitive workload in a hardware-isolated environment
AI governance and evaluationAdopt: regulation and risk are risingAn evaluation suite and an inventory of AI systems
Quantum computingLearn, do not build on it yetSimulate a few circuits; follow error-correction progress

Themes Behind the List

1. Software Is Increasingly Produced by Agents Under Human Direction

Coding agents already write a large share of routine code in many teams. The durable skills move toward specification, decomposition, review, testing and system design. The risk is quality debt: more code, produced faster, that nobody fully understands. Teams that invest in tests, small changes and review discipline benefit; teams that do not, accumulate defects faster than before.

2. Organisations Shrink the Unit of Delivery

Small autonomous teams with clear ownership (pods) plus an internal platform that removes undifferentiated work is the common response to coordination overhead. Platform engineering and pod-based structures reinforce each other.

3. Security Timelines Are Driven by Data Lifetime

Most trends are optional. Post-quantum migration is not, for organisations with long-lived confidential data, because standards bodies have published deprecation timelines for today\'s public-key algorithms. Regulation of AI systems is also tightening in several regions, with timelines that have shifted, so track your own jurisdictions rather than relying on a secondary source.

4. Intelligence Moves to More Places

Small models running on laptops, phones and edge devices handle private, latency-sensitive or offline tasks, while large hosted models handle hard reasoning. The interesting engineering is routing between them.

5. Protocols Matter More Than Models

Standards for how agents discover tools and talk to each other (MCP and others) make integrations reusable. The pattern echoes how REST and OAuth made web integration routine.

What to Be Sceptical About

  • "Autonomous" anything without evaluation data. Ask for measured success rates on tasks like yours.
  • Dates for quantum advantage in useful applications. Roadmaps are targets and have historically slipped.
  • Rewrite-everything pitches. New languages and frameworks rarely repay migration cost unless they remove a specific recurring pain.
  • Single-vendor lock-in presented as a platform. Prefer open protocols and portable data.

Rank Trends for Your Own Context

Edit the scores (0 to 5) and weights below to match your team, then run the script. It is deliberately simple: a weighted sum that turns a discussion into numbers you can argue about. The scores shown are placeholders for an imaginary team, not recommendations:

"""Rank technologies for YOUR context. Edit the scores (0-5) and weights, then run."""
CANDIDATES = {
    #                        business_value  maturity  team_fit  risk_if_ignored  effort(5=hard)
    "Agentic coding workflow":      (5, 3, 4, 4, 2),
    "Platform golden paths":        (4, 4, 3, 3, 3),
    "Post-quantum TLS (hybrid)":    (3, 4, 4, 5, 2),
    "Small on-device models":       (3, 3, 2, 2, 4),
    "WebAssembly components":       (2, 2, 2, 1, 4),
    "Quantum algorithms R&D":       (1, 1, 1, 1, 5),
}
W = dict(value=0.35, maturity=0.20, fit=0.15, risk=0.20, effort=-0.10)

def score(v):
    value, maturity, fit, risk, effort = v
    return (W["value"] * value + W["maturity"] * maturity + W["fit"] * fit
            + W["risk"] * risk + W["effort"] * effort)

def horizon(s):
    return "ADOPT now" if s >= 3.0 else "PILOT" if s >= 2.2 else "WATCH"

for name, v in sorted(CANDIDATES.items(), key=lambda kv: -score(kv[1])):
    s = score(v)
    print(f"{s:4.2f}  {horizon(s):<9} {name}")
3.55  ADOPT now Agentic coding workflow
3.25  ADOPT now Post-quantum TLS (hybrid)
2.95  PILOT     Platform golden paths
1.95  WATCH     Small on-device models
1.20  WATCH     WebAssembly components
0.40  WATCH     Quantum algorithms R&D

The thresholds are arbitrary; the value is in seeing which input drives each ranking. Re-score every quarter, since maturity and your own needs change.

A 90-Day Plan for an Individual Developer

  1. Days 1 to 30: use a coding agent on a real project with tests, and write down where it saved time and where it caused rework.
  2. Days 31 to 60: build one small tool server using an open agent protocol, and run one small model locally for a narrow task.
  3. Days 61 to 90: pick one platform or security topic that your team lacks, such as preview environments or a cryptographic inventory, and deliver a small working version.

The skills that compound across all of these are the unglamorous ones: writing precise specifications, designing tests, reading code critically, and understanding systems end to end.

Frequently Asked Questions

Which emerging technology should developers learn first?

Agentic software engineering has the broadest immediate payoff, since it changes daily work. Pair it with testing and review discipline, then add one platform or security skill your team lacks, such as preview environments or post-quantum migration.

Is quantum computing worth learning for a software developer?

Learn the basics and follow error-correction progress, because it drives post-quantum security planning now. Do not build production systems on quantum hardware yet; simulators are enough to understand the concepts.

How do I decide whether a trend is hype?

Check whether it is deployed at several real organisations, what specific problem it removes for you, how cheap the first experiment is, and what happens if you wait a year. Missing answers usually mean it is early.

Which trend has a deadline attached?

Post-quantum cryptography, because standards bodies have published timelines to deprecate current public-key algorithms and long-lived data can be recorded now and decrypted later. AI regulation also has timelines, which vary by region and have shifted.

Should every team adopt every trend on the radar?

No. Score each trend against your own value, maturity, fit, risk and effort, adopt one or two, pilot one, and ignore the rest until the evidence changes.