Chapter 18 · A Skills Roadmap for 2026 → 2028

A staged, realistic plan for a mid-level backend engineer.

---

You have four years of backend experience, work in Python and Java, know the web stack, and deploy to GCP and AWS. Good foundation. Here's how to stay — and become more — valuable over the next 24 months as the ground continues to shift.

The core idea: don't try to become an ML researcher. Become the backend engineer who builds great agentic systems, with enough ML literacy to read papers and make smart build/buy calls. That role is in enormous demand and will be for the foreseeable future.

In plain English. You don't have to outrun the AI. You have to outrun the median engineer who hasn't bothered to learn how to use the AI well.

A 24-month skills mountain

mindmap
  root((24-month plan))
    Month 1
      Install Claude Code, Cursor
      Ship one AI feature in your job
      Read 3 Anthropic engineering blogs
      Build one MCP server
    Quarter 1
      Deploy a RAG service
      Add function calling to an endpoint
      Write 50-100 evals in CI
      Read DLAI short courses
    Year 1
      Own an agentic service end to end
      Contribute to one OSS AI library
      Run a LoRA fine-tune
      Speak internally on AI
    Year 2
      Architect cross-team AI platform
      Pick a vertical: RAG, agents, or evals
      Mentor one junior into AI fluency
      Build product-level taste

A simpler way to think about it

flowchart LR
    K[Keep
backend fundamentals] --> A[Add
AI fluency]
    A --> R[Reach
architect of agentic systems]
    style K fill:#cfe7ff
    style A fill:#84c0ff
    style R fill:#0a5fcf,color:#ffffff

18.1 The shape of the role shift

flowchart LR
    A["Backend engineer
2022"] --> B["Backend + AI-augmented
2024"]
    B --> C["AI-fluent backend
2026"]
    C --> D["Architect of agentic software
2028"]

What changes at each step:

• 2022: Your value = writing correct code + knowing your systems.
• 2024: Your value = writing correct code + knowing your systems + using AI for 2×.
• 2026: Your value = designing correct systems + stewarding quality + using AI for 5–10×.
• 2028: Your value = designing agentic systems where humans, AIs, and tools cooperate.

18.2 Month 1 — ship one AI feature in your day job

Concrete targets:

• Install and use Claude Code + Cursor daily.
• Read Parts I–III of this handbook.
• Take one real ticket and ship it with AI pair-programming.
• Build one personal MCP server — even a toy one (your todos, your home WiFi, anything). Connect it to Claude Desktop or Cowork.
• Write 10 evals for your most-used prompt.
• Read three Anthropic engineering blog posts.

Budget: 2 hours/day for the month.

18.3 Quarter 1 — get fluent

Concrete targets:

• Deploy a small RAG service on your cloud (pgvector or Bedrock KB or Vertex AI Search). Even if it's "just docs."
• Add function calling to a real backend endpoint. One tool, one real use case.
• Write a suite of 50–100 evals and run them in CI on prompt changes.
• Read Chip Huyen's AI Engineering or Building LLMs for Production.
• Take a DeepLearning.AI short course: Building and Evaluating Advanced RAG.
• Set up cost + latency observability on every LLM call in your team's systems.
• Review five open-source agent repos (LangGraph examples, a few MCP servers) to see how they're organized.

Budget: 8 hours/week for 12 weeks.

18.4 Year 1 — become the team's go-to AI backend engineer

Concrete targets:

• Own an agentic service end-to-end: planner, tools, evals, observability, cost guardrails, human-in-the-loop checkpoints.
• Contribute one feature to an open-source AI library (LangChain, LlamaIndex, an MCP server) or publish a real open-source MCP server of your own.
• ML literacy jump:
• Karpathy's Neural Networks: Zero to Hero (12 hours of video, code along).
• Build a small character-level Transformer from scratch.
• Read 10 foundational papers (see Appendix B).
• Run one LoRA fine-tune end-to-end on an open model. Small task, real data. You'll never fear fine-tuning again.
• Speak internally: brown bag, lunch-and-learn, or tech talk on something AI-adjacent you own.
• Cross-train in one adjacent area: security/adversarial prompting, or eval design, or vector-DB internals, or inference optimization.

Budget: 4 hours/week for 52 weeks.

18.5 Year 2 — architect-track in the agentic era

Concrete targets:

• Design AI systems others build. Lead a "platform team" pattern for LLMs inside your org: shared gateway, caching, evals, secrets, monitoring. This is leverage work.
• Specialize on one vertical axis. Choose one:
• RAG / search — deep on retrieval quality, chunking strategies, rerankers.
• Agents & orchestration — long-running, multi-agent, durable workflows.
• Fine-tuning & eval — cheap distillation, preference optimization, rigorous eval.
• Inference & ops — self-hosted serving, quantization, latency engineering.
• Business context. Translate between product asks and AI constraints. Know which AI features are worth shipping and which are hype. This is the rarest skill.
• Teach externally: a blog, a talk, a YouTube video, a small course. Nothing compounds a career like teaching in public.

Budget: 4 hours/week, compounded.

18.6 The skills matrix

Priority in the next 12 months, assuming a backend engineer starting today:

Skill	Priority	Why
Prompt engineering + evals	P0	Everyone can prompt; few can measure
RAG architectures	P0	The #1 shipped pattern
Tool / function calling	P0	The integration primitive
MCP — server and client	P0	The standard interface
Structured outputs	P0	Used in 95% of production code
Observability for LLMs	P1	You can't improve what you can't see
Vector DBs (pgvector first)	P1	Every RAG touches one
LangGraph or equivalent	P1	Durable, stateful agent workflows
Multi-agent design	P1	Rising; many bad implementations to fix
AI safety & prompt injection	P1	Core responsibility for anyone shipping
Cost + latency optimization	P1	Separates demos from products
Fine-tuning (LoRA)	P2	Rarer, but valuable when needed
Distillation	P2	Huge cost wins at scale
Inference serving (vLLM)	P2	If you self-host
Training from scratch	P3	Only if you change into a lab

18.7 Hedge your bets with systems skills

Do not abandon backend fundamentals. The engineers who will not be replaced are the ones who combine deep systems knowledge — databases, concurrency, distributed systems, observability, security, performance — with fluency in AI.

An agent is a junior engineer who can't find their ass with a flashlight when a deployment fails on a Friday at 4 p.m. You are the senior. Be the senior.

flowchart LR
    A[Core backend
Postgres, concurrency,
distributed systems] --> C[High leverage]
    B[AI engineering
RAG, agents, evals,
MCP, observability] --> C
    C --> D[Rare & valuable
2026-2028]

Neither alone is as valuable as both.

18.8 Learning sources, in priority order

1. Do. 80% of your growth will come from shipping real things.
2. Read papers. Start with 5–10 foundational ones (Appendix B). Then follow the new ones weekly via arXiv Sanity or Papers with Code.
3. Read engineering blogs. Anthropic, OpenAI, Google DeepMind, Stripe, Netflix, Airbnb, Shopify. Simon Willison. Chip Huyen. Ethan Mollick.
4. Watch videos. Karpathy's Zero to Hero. Individual paper walkthroughs. 3Blue1Brown. AI Explained.
5. Take one course a quarter. DeepLearning.AI short courses, Fast.ai, Full Stack Deep Learning.
6. Read one book a quarter. Chip Huyen's AI Engineering, Mollick's Co-Intelligence, Russell's Human Compatible, Christian's The Alignment Problem.
7. Teach. Write. Speak. The best way to know something is to explain it.

18.9 A calendar you can steal

MONDAY
  09:00  Triage + plan
  10:00  Deep work (AI-paired)
  12:00  Review diffs
  14:00  Meetings
  16:00  Weekly: prune one prompt / agent

TUESDAY
  Deep work heavy

WEDNESDAY
  09:30  Same as Monday
  17:00  Weekly: 30 min reading

THURSDAY
  Deep work heavy

FRIDAY
  16:00  Weekly: write a short teach-note
         (internal Slack post or blog draft)
  17:00  Plan next week

WEEKLY
  Contribute 1 commit to an OSS AI project (optional, builds over time)

MONTHLY
  Finish one short course or handbook chapter
  Ship one "personal project" improvement

QUARTERLY
  Read one book
  Give one talk / write one public post

18.10 The realistic ceiling

If you put in ~30 focused minutes of deliberate AI practice per day for 12 months on top of your job, at the end of that year you will be in the top 5–10% of backend engineers by AI fluency. This is not "the top of the field" — but it is a rare and extremely employable position, and it is achievable with no PhD, no research lab, and no lucky circumstance.

Keep the craft. Use the tools. Build the systems. Teach what you learn.

Further reading & watching

• Book — Chip Huyen, AI Engineering — 2024
• Book — Chip Huyen, Designing Machine Learning Systems — 2022
• Book — Louis-François Bouchard & Louie Peters, Building LLMs for Production
• Book — Ethan Mollick, Co-Intelligence
• Book — Stuart Russell, Human Compatible
• Course — DeepLearning.AI short courses — https://www.deeplearning.ai/short-courses/
• Course — Full Stack LLM Bootcamp — https://fullstackdeeplearning.com/
• Course — Hugging Face NLP course — https://huggingface.co/learn
• Course — Fast.ai Practical Deep Learning for Coders — https://course.fast.ai/
• Series — Karpathy's Neural Networks: Zero to Hero — https://www.youtube.com/playlist?list=PLAqhIrjkxbuWI23v9cThsA9GvCAUhRvKZ

---

← Table of Contents