How to Read a Trend
For every trend, ask four questions before spending time on it:
- Is it deployed anywhere real? Production use at several organisations counts; demos and keynotes do not.
- What problem does it remove for us? If you cannot name one, it is a hobby, which is fine, but budget it as one.
- What is the cheapest experiment? Anything that needs a six-month commitment before you learn anything is a bad first step.
- 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
| Trend | Status (our judgement) | First experiment |
|---|---|---|
| Agentic software engineering | Adopt: already changing daily work | One repo, a context file, tests as guardrails, human review of every merge |
| Pod-based team structure | Adopt where teams are large or slow | Reorganise one product area into a long-lived cross-functional pod |
| Platform engineering and golden paths | Adopt gradually | One paved path for the most common service type |
| Ephemeral preview environments | Adopt if you deploy to Kubernetes | A namespace per pull request with automatic cleanup |
| Post-quantum cryptography | Start now for long-lived data | Inventory, then hybrid key exchange on the edge |
| Agent protocols (MCP, A2A) | Adopt MCP; watch agent-to-agent standards | Expose one internal tool as an MCP server |
| Small and on-device models | Pilot for privacy or latency needs | Run a small model locally for one narrow task |
| WebAssembly beyond the browser | Pilot: plugins and edge, still maturing | A sandboxed plugin system for one extension point |
| Confidential computing | Pilot where regulation demands it | A single sensitive workload in a hardware-isolated environment |
| AI governance and evaluation | Adopt: regulation and risk are rising | An evaluation suite and an inventory of AI systems |
| Quantum computing | Learn, do not build on it yet | Simulate 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&DThe 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
- 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.
- Days 31 to 60: build one small tool server using an open agent protocol, and run one small model locally for a narrow task.
- 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.