allsrc.dev
Learning path

AI for Software Engineers

AI for Software Engineers is a learning path that explains how the AI tools you already use actually work, from the model and the context window to harnesses, retrieval, multi-agent systems, evals and security. Each part maps the idea to system design you already know and says when not to use it.

Intermediate22 parts2 h 19 min total readingUpdated

Who it's for

Experienced software engineers who already use AI tools like ChatGPT, Claude Code or GitHub Copilot every day and want to understand how they work and build with them.

What you'll be able to do

  • Tell a model, its harness, an agent and a product apart, and work out which part changed when behaviour shifts.
  • Follow a request from pressing Enter to the model API and back, including streaming, the system prompt and token usage.
  • Manage the context window: why long chats get worse, what compaction loses, and when to prune, summarise or persist.
  • Extend coding agents with instruction files, skills, tools, MCP servers, subagents and hooks, knowing what each costs in context.
  • Design your own harness: loop limits, workflows versus agents, state and durable execution, and when not to use an agent at all.
  • Run an AI system like any distributed system, with evals, observability and governance built in from day one.
Start with Part 0

The parts

Start here

  1. 0Why this series, and how to read itWho this learning path is for, the order of topics from the model to governance, and how to read it one part at a time.3 min read

Models and how they are called

  1. 1.1The model and the applicationThe difference between an AI app like ChatGPT or Claude Code and the LLM behind it, plus open-weight vs closed models and model tiers.6 min read
  2. 1.2Model, harness, agent, productWhat model, harness, agent and product mean, how vendors define them, and when a plain workflow beats an agent. Mapped to system design.6 min read
  3. 2.1It's still client-serverWhat happens when you press Enter: JSON over HTTPS to a stateless model API, request fields across providers, and running models with Ollama.7 min read
  4. 2.2The system prompt, and why text streams inWhat belongs in the system prompt vs the messages, why retrieved documents go in the user turn, and how LLM streaming over SSE works.6 min read

Inside the conversation

  1. 3.1Why you keep seeing "Compacting conversation"Why Claude Code and other tools say "Compacting conversation": tokens, the context window, what compaction drops, and why long chats degrade.6 min read
  2. 3.2Switching models, the words you keep hearing, and three ways to manage contextWhy switching models mid-chat is slower (the prompt cache is per model), the terms you keep hearing, and three ways to manage context.6 min read

Extend the AI you already use

  1. 4.1Instructions, skills and toolsWhere repeated instructions belong: CLAUDE.md and AGENTS.md, Agent Skills that load only when relevant, and tools the model asks your app to run.6 min read
  2. 4.2MCP, and where your agent keeps what it knowsWhat MCP is, why every connected server costs context before you ask anything, and where an agent keeps knowledge: context, retrieval or memory.7 min read
  3. 4.3Subagents, hooks, and building something smallWhy subagents exist (a clean main context), how hooks, commands and plugins plug into a coding agent's harness, and a small build to try.7 min read

Build your own harness

  1. 5.1Your own harness, the agent loop, and workflows versus agentsWhen to build your own harness, what decides when an agent loop stops, and how to choose between plain code, a workflow and an agent.6 min read
  2. 5.2Design it like softwareWhy the same request takes a different path each time, and how deterministic pipelines and spec-driven development make agent work predictable.7 min read
  3. 5.3Frameworks, state, and when not to use an agentFrameworks vs harnesses vs runtimes, checkpoints and durable execution so a crash doesn't repeat side effects, and when to skip a framework.6 min read

Knowledge and beyond text

  1. 6Change the prompt, the context, or the model?When an LLM app's answers aren't good enough: measure, then change the prompt, the context, the model and, last of all, fine-tune.6 min read
  2. 7Why your assistant doesn't know your docs, and how retrieval fixes itWhy your assistant doesn't know your docs and how retrieval fixes it: keyword, vector, hybrid and agentic search, access control, and when not to use RAG.7 min read
  3. 8Beyond textHow images, documents, video and voice reach a model, why voice agents pause, a call centre end to end, and an honest look at computer use.6 min read

Many agents, many failure modes

  1. 9When one agent isn't enoughWhen more than one agent helps, the patterns (orchestrator, handoff, fan-out, critic), what they cost, MCP vs A2A, and passing identity.7 min read
  2. 10It's still a distributed systemAgents are distributed systems: boundaries, idempotency keys, retries, timeouts, token rate limits, spend limits and model retirement.7 min read

Prove it and secure it

  1. 11How do you know it works?How to know an agent works: evals from real cases, assertions on result and path, model-graded checks, repeated runs, tracing, release gates.7 min read
  2. 12Governance and security, from day oneWhy prompt injection can't be filtered away, the lethal trifecta, whose permissions an agent uses, least privilege, human approval and audit.7 min read

In practice

  1. 13Taking it to the customerHow a forward deployed engineer takes AI to a customer: narrow to one task, agree the numbers, check the data, and move from demo to production.6 min read
  2. 14Putting it together, one support line end to endOne hypothetical support line through every layer: model, context, tools, retrieval, workflow, evals, risks and rollout, compared with a coding agent.7 min read

About this path

Why this path exists

I know a lot of software engineers who are very good at their jobs. Some have 14 or 15 years behind them. They can design a system and argue about boundaries and data flows. And they still feel they haven’t got a grip on AI.

It isn’t that the skills aren’t there. AI is a huge area with many branches, and most of what’s written starts somewhere that makes no sense yet. “Let’s learn RAG.” Fine, but if you don’t yet know what a model actually is, how context works, or what a harness does, you won’t know how to use RAG, and more importantly you won’t know when not to.

So this path doesn’t try to cover every branch of AI. It gives you a direction, and the areas that are useful for building in 2026.

Where it goes

It starts from what you already use, ChatGPT, Claude, Gemini, Claude Code or GitHub Copilot, and keeps coming back to things you’ve already noticed: why a long chat gets worse, why you keep seeing “compacting conversation”, why switching models halfway through feels different. Roughly in this order:

  • What a model is, what the application around it is, and the vocabulary: model, harness, agent, product.
  • What happens when you press Enter: the request, the system prompt and streaming.
  • Inside the conversation: context, compaction, hallucination and a few surprising behaviours.
  • Extending the AI you already have: instructions, skills, tools, MCP, memory, subagents and hooks.
  • Your own harness: agent loops, workflows versus agents, state and durable execution, and when not to use an agent at all.
  • Retrieval, and going beyond text: images, voice and a call centre end to end.
  • More than one agent, and all of it as a distributed system.
  • Evals, observability, governance and security. Security starts on day one, not at the end.

How to read it

In order, one part at a time. It might take hours or days, and that’s fine. Each part starts from something you’ve seen, asks the question before answering it, ties the idea to something you already know from system design, and says when not to use it. Where the details change fast, it points you to the provider’s docs instead of copying numbers, because this field moves every month.