Skip to content
Linear Horizon Training

Ready-made course · 3 days · Intermediate

AI Engineering for Software Developers

A three-day programme for professional software engineers: how to build real applications with modern AI, from model APIs and RAG through agents, evaluation and production patterns.

Most software engineers are now expected to put large language models into applications. The gap is not access to an API. It is the engineering around it: structured outputs, retrieval, tools, evaluation, security, testing and the production behaviour of a non-deterministic component.

This course teaches those fundamentals before any particular framework. You call models, constrain outputs, build embeddings and retrieval, then add tool calling, agents and orchestration. Context engineering, evaluation and observability are treated as part of the design, not as later extras.

The labs are substantial. You write working software, compare approaches, and learn to recognise when a framework is helping and when it is hiding a design you will have to own. The course is not bound to a single vendor SDK or agent library.

After three days, you can design and implement AI-backed features with the same seriousness you would apply to any other production integration: interfaces, failure modes, tests, and an honest account of what the model is allowed to do.

Who it is for
Professional software developers with little or moderate AI experience. Suitable for senior developers and technical leads who will implement, review or own LLM-backed features.
Before you start
Professional software development experience and comfort writing backend or full-stack code. Familiarity with HTTP APIs and JSON is expected. Python or TypeScript is used in labs; the concepts are not language-specific. No machine-learning background is required.

You will be able to

  • Implement LLM API calls with streaming, retries, structured outputs and explicit model selection.
  • Design prompts and output schemas that can be tested rather than tuned by anecdote.
  • Build embeddings, vector search and a retrieval pipeline that can be inspected and evaluated.
  • Implement tool calling and a bounded agent loop, including failure handling and permissions.
  • Apply context engineering: what to put in context, what to retrieve, and what to keep out.
  • Evaluate quality with golden cases, semantic checks and traces, not only manual chat.
  • Diagnose security, cost, latency and observability issues in an LLM-backed service.
  • Deploy a production pattern: a service boundary, logging, and tests around a non-deterministic component.

Modules

12 quarter-day modules. Each one can go into a custom course on its own.

  1. Working with LLM APIs

    • API keys and authentication.
    • Sending and receiving requests, structured JSON and streaming.
    • Managing context and conversation state.
    • Cost and token management.
    • Enough Python to understand and change the examples. All code is supplied, with starting points and worked solutions.
  2. Prompts and schemas as tested interfaces

    • Prompts as code: instructions, examples, constraints and versioning.
    • Structured outputs and JSON Schema: a request, not a guarantee.
    • Separating trusted instructions from untrusted input.
    • Lab: write a prompt with tests, then break it with realistic inputs.
  3. Context engineering and memory

    • What goes into context, what is retrieved and what is left out.
    • Long conversations: truncation, summaries and their failure modes.
    • Short-term and long-term memory, and when to forget.
    • Prompt caching and its effect on cost and latency.
  4. Embeddings and vector search

    • Embedding models: choosing, comparing and versioning.
    • Vector indexes, similarity and approximate search.
    • Filters and namespaces.
    • Lab: index a corpus and run a question set against it.
  5. Grounded answers and citations

    • Assembling a grounded prompt from retrieved chunks.
    • Citations a reader can follow back to the source.
    • Refusing when retrieval is empty or sources conflict.
    • Lab: complete the RAG path and test it on held-out questions.
  6. Measuring retrieval

    • A question set with known good sources.
    • Recall, precision and ranking metrics.
    • Faithfulness and answer relevance.
    • Lab: compare two retrieval configurations with numbers, not impressions.
  7. Designing tools for models

    • Tool names, descriptions and schemas a model uses correctly.
    • Validating arguments before any side effect.
    • Errors the model can recover from.
    • Lab: wrap an existing API as a set of tools.
  8. Agent loops, planning and state

    • The agent loop, step by step.
    • Planning, ReAct and reflection.
    • State, memory and stopping conditions.
    • Lab: build a loop without a framework, then compare one.
  9. Golden datasets and evaluators

    • Building a golden set from real traffic and expert input.
    • Code-based evaluators and LLM-as-judge.
    • Calibrating a judge against human labels.
    • Lab: build a golden set and score two prompt versions.
  10. Observability for LLM systems

    • Traces for prompts, retrieval, tool calls and responses.
    • Prompt and model versions, token counts and latency.
    • OpenTelemetry and LLM tracing tools.
    • Lab: trace a request end to end and find the slow step.
  11. Prompt injection and poisoned context

    • Direct and indirect prompt injection.
    • Poisoned documents, retrieval and tool results.
    • Mitigations that help, and the ones that only look as if they do.
    • Lab: attack a RAG assistant, then defend it.
  12. Cost, latency and caching

    • Where the tokens go, and how to measure cost per task.
    • Model routing: small models first, large models when needed.
    • Prompt caching, response caching and batch APIs.
    • Streaming and perceived latency.

Practical work

The course is lab-heavy. You build against model APIs, add structured outputs and tests, implement retrieval, then introduce tools and a bounded agent. The final work is a small service with evaluation, tracing and explicit failure behaviour rather than a chat demo.

You take away

  • Working code for API integration, RAG, tool calling and evaluation
  • Reference implementations that are not tied to a single framework
  • Prompt, schema and evaluation templates
  • A production checklist for LLM-backed features

Combine it with

Contact