AI Tools for Developers: From Basics to Advanced

Updated July 2026 | 10 modules | Practical labs | Beginner-to-advanced pathway No previous AI experience is required. The course begins with simple definitions, safe first steps, and everyday examples. It then progresses gradually through prompting, AI-assisted coding, coding agents, Model Context Protocol (MCP), multi-agent systems, security, evaluation, and production workflows.

How to complete the course

  • Work through Modules 1-10 in order.
  • Complete each practical lab in a disposable test project.
  • Keep secrets outside source code and never give an agent more authority than it needs.
  • Save prompts, traces, test results, and decisions as evidence for the final capstone.

Module 1 – AI Basics: Your First Steps

No previous experience required

This module starts at the very beginning. You do not need to understand programming, machine learning, or mathematics. You only need access to a web browser and an AI assistant.

What is artificial intelligence?

Artificial intelligence is software designed to perform tasks that normally require human intelligence, such as understanding language, recognising patterns, creating text or images, and helping solve problems. Modern AI assistants use large language models, often shortened to LLMs, trained on large collections of text and code.

Essential beginner terms

  • AI model: the underlying system that produces an answer.
  • AI assistant: the website or application through which you use a model.
  • Prompt: the instruction or question you give the assistant.
  • Response: the content created by the assistant.
  • Token: a small unit of text processed by a model.
  • Context: the information available to the model during a conversation.
  • Hallucination: an answer that sounds confident but is incorrect or invented.

Your first safe workflow

  1. Choose a simple, non-sensitive task.
  2. Write a clear prompt explaining the desired result.
  3. Read the response critically.
  4. Check important facts using a trustworthy source.
  5. Revise the prompt and compare the improved result.

What AI can and cannot do

AI can explain concepts, draft text, summarise information, generate examples, suggest code, and support brainstorming. It does not automatically know whether its answer is correct, current, secure, or suitable for your situation. A human remains responsible for checking and approving the result.

Beginner safety rules

  • Never paste passwords, API keys, private student data, financial information, or confidential business documents into an AI tool.
  • Do not run commands or code you do not understand.
  • Verify medical, legal, financial, security, and production decisions with qualified sources.
  • Use AI as an assistant, not as an unquestioned authority.

Lab 1 – Your first structured prompt

Ask an AI assistant: “Explain what an API is to a complete beginner. Use one everyday analogy, five short bullet points, and a three-question knowledge check. If you are uncertain about anything, say so.” Review the answer, verify one claim, then improve the prompt once.

Module 1 completion check

You are ready to continue when you can explain the difference between a model, an assistant, a prompt, a response, context, and a hallucination.

Module 2 – Prompt Engineering as Specification Engineering

Learning outcomes

Write prompts that behave like testable software specifications and produce dependable structured results.

Professional prompt pattern

  • Role and objective: define the job and the required outcome.
  • Context: include only relevant repository, business, and user information.
  • Constraints: state security, compatibility, style, performance, and scope limits.
  • Acceptance tests: describe exactly how success will be checked.
  • Output contract: require a schema, diff, checklist, or other machine-verifiable format.

Advanced techniques

Use decomposition for complex work, examples for format control, retrieval for external facts, and explicit uncertainty when evidence is missing. Separate trusted system instructions from untrusted data. Never paste secrets into prompts.

Lab 2

Create a prompt that asks an AI to implement input validation. Include repository context, non-goals, edge cases, test requirements, and a JSON result schema. Run it three times and measure schema validity and test pass rate.

Module 3 – AI-Assisted Coding and Code Review

Learning outcomes

Use inline assistants and chat tools without sacrificing engineering judgment, security, or maintainability.

Workflow

  1. State the smallest safe change.
  2. Ask for a plan before code when multiple files are involved.
  3. Generate or update tests with the implementation.
  4. Review every diff, dependency, migration, and command.
  5. Run formatting, linting, type checks, tests, and security checks.

Review checklist

  • Does the code match the project architecture?
  • Are error paths, concurrency, cancellation, and resource cleanup handled?
  • Are secrets, personal data, and authorization boundaries protected?
  • Are APIs and dependencies real, supported, and correctly versioned?
  • Do tests verify behaviour rather than simply mirror the implementation?

Lab 3

Use an assistant to refactor a small service. Require a baseline test run, an implementation plan, a minimal diff, new edge-case tests, and a final verification report. Reject any change you cannot explain.

Module 4 – Agent Mode, Cloud Coding Agents, and Isolated Work

Learning outcomes

Choose between local agent mode, terminal agents, and cloud coding agents; supervise long-running work safely.

Current workflow models

  • Ask mode: explanation and exploration without autonomous editing.
  • Plan mode: repository analysis and an implementation plan before changes.
  • Local agent mode: edits files and runs commands in the developer’s environment.
  • Cloud coding agent: works asynchronously in an isolated environment, creates a branch, runs checks, and proposes a pull request.

Isolation strategy

Use a dedicated branch, git worktree, container, or cloud sandbox for each agent task. Give each task a clear boundary, test command, maximum runtime, and definition of done. Parallel agents must not modify the same workspace.

Lab 4

Delegate two independent tasks in isolated branches: one improves test coverage and one updates documentation. Review commits separately, run the full CI pipeline, then integrate only verified changes.

Module 5 – Tool Calling and the Responses/Agent Loop

Learning outcomes

Build an agent loop that calls typed tools, validates arguments, handles failures, and stops predictably.

Agent loop

  1. Send instructions, user input, and available tool schemas.
  2. The model returns text, structured output, or tool calls.
  3. The application validates the tool name and arguments.
  4. Authorization and approval checks run before side effects.
  5. The application executes the tool and returns a bounded result.
  6. The loop continues until a final answer, limit, error, or approval pause.

Production controls

  • Strict JSON schemas and server-side validation
  • Idempotency keys for retryable writes
  • Timeouts, concurrency limits, and maximum agent turns
  • Allowlisted tools and least-privilege credentials
  • Human approval for destructive, financial, publishing, or permission-changing actions

Lab 5

Create three tools: search documentation, read an issue, and draft a change plan. Keep all tools read-only. Add schema validation, timeouts, and a maximum of six agent turns.

Module 6 – Model Context Protocol (MCP)

Learning outcomes

Understand MCP clients, servers, tools, resources, prompts, transports, authorization, and trust boundaries.

Architecture

MCP standardizes how AI applications discover and use external capabilities. A host application connects through an MCP client to one or more servers. Servers can expose tools for actions, resources for context, and reusable prompts.

Security design

  • Inspect server provenance, permissions, and tool schemas before connecting.
  • Separate read-only servers from servers that can write or execute.
  • Treat every tool result and external resource as untrusted input.
  • Use scoped credentials, explicit authorization, audit logs, and approval gates.
  • Disable unused tools and never expose unrestricted filesystem or shell access by default.

Lab 6

Connect a trusted read-only MCP server in a test environment. Inventory every exposed tool, document its data access, test malformed input, and write a threat model before enabling any write capability.

Module 7 – Multi-Agent Orchestration

Learning outcomes

Design coordinated agent systems using managers, agents-as-tools, handoffs, and specialized workers.

Patterns

  • Manager pattern: one orchestrator retains control and calls specialists as tools.
  • Handoff pattern: control transfers to a specialist that becomes responsible for the next part of the interaction.
  • Parallel workers: independent subtasks run concurrently and their results are merged.
  • Reviewer pattern: a separate evaluator checks evidence, tests, policy, and completeness.

Design rules

Use the smallest number of agents necessary. Define each agent’s purpose, allowed tools, input/output schema, completion condition, and escalation path. Shared context should be minimal and explicit. More agents increase coordination cost, latency, and failure modes.

Lab 7

Build a manager with three specialists: repository analyst, implementation planner, and security reviewer. The manager must produce one structured final plan containing evidence from all three.

Module 8 – Retrieval, Memory, Context, and Durable Workflows

Learning outcomes

Design reliable retrieval and memory while controlling stale data, privacy risk, and context growth.

Retrieval pipeline

  1. Ingest authoritative sources with ownership and timestamps.
  2. Chunk by semantic structure rather than arbitrary size alone.
  3. Attach access-control and source metadata.
  4. Retrieve, rerank, and filter before generation.
  5. Cite sources and evaluate answer faithfulness.

Memory

Separate conversation state, user preferences, task state, and long-term knowledge. Store only what is necessary, apply retention rules, support correction/deletion, and never treat remembered text as trusted instructions.

Durability

Long workflows need checkpoints, resumable state, idempotent operations, event logs, and clear human-approval pauses. A retry must not duplicate side effects.

Lab 8

Create a retrieval assistant over five official documents. Require citations, return “insufficient evidence” when appropriate, and evaluate it with ten questions containing both answerable and unanswerable cases.

Module 9 – Security, Guardrails, Evaluations, and Observability

Learning outcomes

Defend agent systems against prompt injection, data leakage, excessive agency, unsafe tools, and silent quality regression.

Threats

  • Direct and indirect prompt injection
  • Tool argument manipulation and confused-deputy attacks
  • Secret or personal-data leakage through prompts, logs, traces, and retrieval
  • Excessive permissions and unreviewed side effects
  • Poisoned knowledge sources, insecure output handling, and supply-chain risk

Defence in depth

  • Least privilege, sandboxing, network restrictions, and scoped credentials
  • Input, tool-input, and output guardrails
  • Human approval at consequential boundaries
  • Structured outputs and deterministic validation
  • Trace model turns, tool calls, approvals, errors, latency, and token usage while excluding sensitive data
  • Run regression evaluations on every prompt, model, tool, or workflow change

Lab 9

Red-team your agent with malicious web content, hidden instructions, malformed tool arguments, data-exfiltration requests, and runaway loops. Record failures, add controls, and rerun the same evaluation set.

Module 10 – Production Capstone: A Professional Repository Agent

Objective

Build a production-style agent that analyses a repository issue, prepares a change, validates it, and produces a reviewable delivery package.

Required components

  1. A written problem statement, non-goals, and acceptance tests
  2. An isolated workspace and least-privilege tool set
  3. A planning stage before implementation
  4. Typed tools or trusted MCP capabilities
  5. Tests, linting, type checking, and security scanning
  6. A reviewer agent or deterministic review checklist
  7. Human approval before committing, publishing, or opening a pull request
  8. Tracing, usage measurement, retry limits, and failure recovery
  9. A final report with files changed, commands run, test evidence, known risks, and rollback steps

Completion standard

The capstone is complete only when the full test suite passes, security checks are reviewed, every side effect is attributable, the result can be reproduced, and a human can understand and approve the final diff.

Professional quick-reference checklist

  • Start with a specification and measurable acceptance tests.
  • Use the least capable model and smallest tool set that meet the need.
  • Plan before multi-file or high-risk changes.
  • Isolate agent work and keep version-control checkpoints.
  • Validate every tool call and structured output server-side.
  • Require approval for consequential actions.
  • Trace behaviour, evaluate quality, and protect sensitive data.
  • Keep a rollback path and never trust generated code without testing.

Official references and further study

Technology changes quickly. Verify model names, pricing, limits, and product availability in the official documentation before production use.

Next