Claude Code

AI-Assisted Software Development Foundations

Build, Explore and Review with Claude Code

Overview

AI coding tools can now build, explain, fix and test software from plain-language instructions. This two-day course is a first step for people who have never worked with them, including those with little or no coding experience. It uses Claude Code throughout, and the habits it teaches carry over to other tools such as Cursor, Codex and GitHub Copilot.

The first day covers how these tools work, how to direct them with clear prompts, and a first build from an empty folder. The second day moves into real projects: finding your way around an existing codebase, fixing a bug, adding a feature and writing tests, then setting up project guidance and learning where to apply human judgement.

Format: Short explanations, each followed by guided practice in Claude Code on small projects that are provided. No development background is assumed, and every exercise can be repeated afterwards on your own machine.

Who it's for

Anyone who wants a safe, structured start with AI-assisted development. It is especially suited to:

  • Non-coders and occasional coders who want to build or change small projects
  • QA, data, product and operations roles working close to engineering teams
  • Developers who are new to AI coding tools
  • Team leads deciding how their people should start

Prerequisites

  • No prior coding or AI-tool experience is required
  • Basic familiarity with code or Git is helpful but not essential

By the end of this course you will be able to

  • Explain how AI coding tools work, including context windows and statelessness, and describe what they do well and where they struggle
  • Write prompts with the GCES method (Goal, Context, Expectations, Source) and use a plan, execute and review cycle
  • Build a small project from an empty folder with Claude Code, then improve, test and refine it step by step
  • Explore an unfamiliar codebase and use Claude Code to fix a bug, add a feature and write tests
  • Give Claude Code lasting project guidance in a CLAUDE.md file
  • Review AI-generated changes critically, recognise common failure modes and prompt injection, and decide what to delegate

Course outline

Times show the standard running order and can be adjusted when we tailor the course to your team. The trainer stays available during breaks to help anyone finish an exercise.

09:30
Welcome & orientation 10 min

How the two days run, what you will build, and a quick round of what each person hopes to do with AI coding tools.

09:40
How AI coding tools actually work 45 min

What happens between your instruction and the code that appears: the context window and why it fills up, why the assistant starts each session knowing nothing about your last one (statelessness), and the plan, execute, review cycle that keeps work on track. Where these tools shine, where they struggle, and habits for working well with them.

Try it: Give Claude Code the same small request twice, once in a fresh session and once after a long conversation, and note what it forgets.
10:25
The AI coding landscape 35 min

A map of today's tools, from editors with built-in assistants to agents that work in a terminal or the cloud. How tools such as Cursor, GitHub Copilot, Codex and Claude Code differ in the way they work, how to match a model and a tool to a task, and sensible ways for a team to begin. Compared on criteria, not ranked.

Try it: Fill in a one-page comparison of two tools you have access to for three tasks from your own work.
11:00
Break 15 min
11:15
Setting up Claude Code 40 min

Installing Claude Code, signing in, and starting a first session, either in a terminal or in the Code tab of the Claude desktop app. A tour of what you see on screen, how permission prompts work and how to stop or undo.

Try it: Install Claude Code, ask it to explain the sample project in your folder, and approve one action and decline another.
11:55
Prompt anatomy 50 min

What a good instruction contains: the task, the context, the output you expect and the constraints. We use GCES (Goal, Context, Expectations, Source) as the main method and compare it with other common prompting frameworks and templates. Ways to make prompts clearer and results more consistent.

Try it: Rewrite three vague requests as GCES prompts and compare what Claude Code produces from each.
12:45
Lunch 45 min
13:30
First coding: building from an empty folder 50 min

Starting a project from nothing. Asking for a plan first, then letting Claude Code create the folder structure and starter files, and installing and configuring what the project depends on, with you approving each step.

Try it: Ask for a plan for a small web page or script of your choice, review it, then have Claude Code scaffold it.
14:20
First coding: improving, testing and refining 45 min

Making the first version better one small request at a time, running it, reading error messages together with Claude Code, and asking it to check its own work before you accept the result.

Try it: Make three improvements to your project, run it after each one, and use a failing run to practise asking for a fix.
15:05
Break 15 min
15:20
Day 1 practice: your own small project 60 min

Put the day together on a small idea of your own. Plan it, prompt it with GCES, build it, test it and write down what worked, with help from the trainer.

Try it: Finish a working first version of your project and show it to a partner, explaining one prompt that made a difference.
16:20
Close 10 min

Recap of Day 1 and what we will build on tomorrow.

09:30
Welcome back 10 min

Questions from Day 1 and the plan for today.

09:40
Exploring an unfamiliar codebase 45 min

Opening a project you did not write and asking questions in plain language: what does this do, where does a feature live, what depends on what. Using Claude Code to map the structure and dependencies before changing anything.

Try it: Ask five questions about the sample codebase, then ask for a diagram or outline of how its main parts connect.
10:25
Documentation, summaries and onboarding 35 min

Generating a README, technical summary or onboarding guide from the code itself, checking it against what the code really does, and using it to bring a new colleague up to speed faster.

Try it: Generate an onboarding note for the sample project and correct two things in it that are wrong or unclear.
11:00
Break 15 min
11:15
Everyday tasks: investigating and fixing a bug 50 min

Describing a symptom, asking Claude Code to find the cause, proposing a fix and proving the fix works. Asking for the root cause rather than a quick patch.

Try it: Reproduce a bug in the sample project, find its cause with Claude Code and confirm the fix by running the project again.
12:05
Everyday tasks: a new feature 45 min

Planning a small enhancement, implementing it in steps and checking the result against what you asked for. Keeping changes small enough to review, and using the plan, execute and review cycle again.

Try it: Add one small feature to the sample project from a short written request, and review the changes Claude Code made.
12:50
Lunch 45 min
13:35
Everyday tasks: writing and improving automated tests 45 min

Asking for automated tests that describe the behaviour you care about, running them, and improving weak ones. Why a passing test is only useful if it can fail, and how tests help you trust generated changes.

Try it: Have Claude Code write tests for one function, then deliberately break the function to see whether the tests notice.
14:20
Project guidance with CLAUDE.md 50 min

How Claude Code learns your project's rules: the CLAUDE.md file and rules files, what belongs in them and what does not, and where they apply. If your team already keeps an AGENTS.md for other tools, Claude Code does not read it directly, so a CLAUDE.md can import it. A short look at more advanced ways to personalise an assistant (skills, subagents and connected tools), which the follow-on courses cover.

Try it: Run /init on the sample project, trim the result to the ten lines that matter and test whether Claude Code now follows them.
15:10
Break 15 min
15:25
Guardrails, risks and judgement 55 min

A practical review routine for generated code. How these tools fail (invented functions, outdated advice, code that almost works), how instructions hidden in files or web pages can mislead an agent (prompt injection), and how to decide what to delegate. You stay accountable for what ships.

Try it: Review a planted, flawed change using a checklist, then sort ten example tasks into delegate, supervise or do yourself.
16:20
Close: your next steps 10 min

Recap, a plan for your first week of using these tools at work, and where to go next in the Claude Code series.

What you'll need

Claude Code

  • A Claude account that includes Claude Code: a Pro, Max, Team or Enterprise plan, or a Claude Console account (the free plan does not include it). Organisations may instead provide access through a cloud provider.
  • A laptop that can run Claude Code (a current macOS, Windows or Linux system with at least 4 GB of memory) and an internet connection. Installation is covered at the start of the course.
  • A free code editor is helpful but not required. Git is recommended; the trainer will help you install it if needed.
  • If you want to try the same ideas in Cursor, Codex or GitHub Copilot, bring your own licence; the course is taught in Claude Code.

Practice files are provided for every exercise. You are welcome to use your own non-confidential projects where your organisation's policy allows.

Related courses

Claude Code Agentic Development with Claude Code 14 hours (2 days × 7 hours) · Intermediate to Advanced Claude Code Claude Code in Practice 7 hours (1 day) · Intermediate Claude Code Claude Code in the Enterprise 14 hours (2 days × 7 hours) · Intermediate

Not sure which course is right for your team?

Book a free discovery call. We'll talk through your team, your tools and what you want to achieve, then recommend the right course or design a bespoke one.

Book a free discovery call Send an enquiry
From £1,50014 hours (2 days × 7 hours)
Enquire