Agentic Software Development: Classroom Bootcamp

An eight-hour classroom bootcamp on developing software with coding agents such as Claude Code, taught on a real production code base. Smarter is a code base shaped for agents: nearly all of its new code is now designed, written and tested by agents working from CLAUDE.md and the sixteen Agent Skills in skills/, and its git history shows it: since late September 2026, most commits have been authored by Claude. Its ImageSearchPlugin was built by Claude Code in a live class demonstration, from the request to a merged pull request with tests and documentation. Students read the instructions that make this work, delegate real tasks in their own fork, review the results as they would a colleague’s, and write a skill of their own. See Course Formats and Grading for the standard bootcamp day, the grading scale and the course policies, and Agentic Software Development with Claude Code for an overview of the subject.

At a Glance

Students

Software developers who write Python or JavaScript, and want to work effectively and responsibly with coding agents.

Deployment

Each student runs Smarter from source, installed before the bootcamp, with a fork on GitHub and Claude Code (or another coding agent) installed and signed in.

Cost

A coding agent subscription or API usage for each student, typically a few dollars for the day with API billing, plus small model charges from Smarter’s tests.

Learning Objectives

By the end of the bootcamp, students can:

  1. Explain how a coding agent works: a model in a loop with tools, context, and instructions.

  2. Delegate a broad, well-bounded task to an agent, with clear acceptance criteria.

  3. Review agent-written code critically, including its tests, and recognize a test that was weakened rather than a bug that was fixed.

  4. Explain how CLAUDE.md and Agent Skills shape an agent’s work, and write a skill.

  5. Discuss authorship, responsibility and security when agents write code.

Technical Prerequisites

  • Required: Python or JavaScript, well enough to read and review a pull request in either.

  • Required: Git and GitHub: branches, diffs, pull requests and code review.

  • Required: the command line, and Docker basics.

  • Required: Smarter installed from source and running, and a coding agent installed and working in the repository, before the bootcamp.

  • Required: basic generative AI concepts: prompts, context windows and tool calls.

  • Helpful: experience with automated tests, and with Markdown.

Schedule

The files that the lectures refer to are listed in full under Smarter in the Source Code.

Block

Min

Content

1

45

Lecture 1: What a coding agent is. A model in a loop: reading files, running commands, editing code, and checking its work. Context windows, tools and permissions. Why the code base matters more than the prompt.

2

45

Lab 1: Read the instructions. Read CLAUDE.md, skills/README.md, skills/smarter-development/SKILL.md and one narrower skill, such as smarter-infrastructure-safety or smarter-docker-environment, and list what they tell an agent to do and never do, and why. Produces Assignment 1.

3

45

Lecture 2: How you ask. Outcomes, not steps; giving the evidence for narrow problems; saying what “done” means; and the pattern-first workflow. A walk through the body of the ImageSearchPlugin commit as an example of a broad, well-bounded task done end to end. Agentic Development.

4

45

Lab 2: Delegate a task. Ask the agent for a broad, bounded change, such as a new optional field on a resource with tests and docs, and let it work. Produces Assignment 2.

5

45

Lecture 3: Reviewing agent code. Reading a diff you did not write; checking tests against the behavior; weakened assertions, skipped tests, swallowed errors and invented APIs; running the tests and hooks yourself.

6

45

Lecture 4: Skills. How Agent Skills work, when they load, what belongs in a skill and what belongs in the code, and how Smarter’s skills grew from repeated mistakes: the caching rules added by commit eeb7a7a19, the zsh word-splitting trap behind sync-changed-files.sh, and the same format reused as a product feature in the SkillPlugin.

7

45

Lab 3: With and without. Give the same task to the agent twice, once with the skills and once with them removed from a scratch branch, and compare the results. Produces Assignment 3.

8

45

Lecture 5: Safety. Permissions, sandboxing, live credentials (and why Smarter’s instructions forbid touching real infrastructure from tests), secrets in prompts, prompt injection through files, and never letting an agent push.

9

45

Lab 4: Write a skill. Choose a mistake the agent made today, and draft a skill that prevents it. Ungraded.

10

45

Lecture 6: Responsibility. Who is the author of agent-written code, who reviews it, attribution in commits, licenses, and how the developer’s job is changing.

11

30

Capstone kickoff. Students choose a capstone and write its acceptance criteria.

Smarter in the Source Code

Every lecture, lab and assignment in this course rests on the files and commits below. Every reference is to the main branch of github.com/smarter-sh/smarter, so that students can open each one during class. Python paths are under smarter/smarter/.

The Instructions an Agent Reads

Topic

What Smarter does

Where to look

Project instructions

One short file that every session loads: what Smarter is, eight hard rules (never run git write commands, fake every cloud call in tests, run the tests yourself, never build the 20-minute Sphinx build, the pre-commit hooks are the lint standard, a coverage floor, a public repository, and when live LLM calls are allowed), a repository map, and the definition of done.

CLAUDE.md

The skills index

Sixteen Agent Skills in one folder, symlinked to .claude/skills so that Claude Code finds them, with a README written for the humans who maintain them.

skills/, skills/README.md

The entry skill

Loaded first for any change: the non-negotiable rules, the pattern-first workflow, the caching and Pydantic rules, and a table that says which narrower skill to load next.

smarter-development/SKILL.md

Canonical references

Long, worked examples that a skill points to, read only when needed: a complete resource kind, a test module, a Sphinx page, a Django-hosted React app and a commit message.

smarter-sam-resource/references/, smarter-python-testing/references/, smarter-git-commits/references/

Scripts the agent runs

Fast checks that replace slow ones, so the agent can verify its own work in seconds: link and autodoc checks instead of the Sphinx build, and scripts that copy changed files into containers that have no bind mount.

check-docs.sh, sync-changed-files.sh, sync-to-containers.sh

Agent-facing documentation

Smarter’s Sphinx documentation is written as much for agents as for people, and its docstrings are published by autodoc, so an agent can read the intent behind a module. ADR 029.

docs/source/, smarter-docstrings/SKILL.md

What the Code Base Gives the Agent

Property

What Smarter does

Where to look

Existing, similar code

Every Django app has the same layout (manifest/, models/, api/, serializers.py, tests/), so a fourth resource kind is copied from three. The newest, cleanest examples are named in the skills.

apps/guardrail/, apps/secret/

A thorough test suite

More than five thousand unit tests, a coverage floor of 90% per app, and one test module per source module. ADR 013.

smarter-python-testing/SKILL.md, codecov.yml

Hooks that catch the agent

black, flake8, isort, autoflake, bandit, codespell, pyupgrade, Prettier, ESLint, secret detection and commitlint run on every commit, and the CI workflow repeats the React format, lint and type checks before running both test suites.

.pre-commit-config.yaml, test.yml

Types and schemas

Pydantic models for every manifest and contract, and Smarter...Type aliases instead of Any, so a wrong guess becomes an immediate error. ADR 031.

lib/typing.py, smarter-python-typing/SKILL.md

Useful logs

Every log line starts with the dotted path of the code that wrote it, and verbose logging is switched on per subsystem with waffle switches. ADR 011.

lib/logging/, lib/django/waffle/switches.py

A safe place to experiment

The development containers hold live cloud credentials, so tests replace every DNS, certificate, Kubernetes and email call with an in-memory provider, and tests that touch real infrastructure are tagged and skipped.

smarter-infrastructure-safety/SKILL.md, infrastructure/providers/memory.py

Agent Work in the History

Since late September 2026, most commits to Smarter have been authored by Claude, and they carry most of the lines added in that time. Students can check this themselves with git shortlog -sn --no-merges HEAD --since=2026-09-29. The commits below are worth reading in full: each body explains what was wrong, what changed, and how it was tested.

Commit

Why it is worth studying

Where to look

ImageSearchPlugin

A complete new resource kind, built by Claude Code in a live class demonstration: plugin, Pydantic manifest models, broker, migrations, sample manifests, React fixes, docs and tests, merged in pull request #775.

commit 1da6bccc3, plugin/plugin/image_search.py, PR #775

A mistake turned into a skill

A fix for caching design mistakes in plugins and the MCP client, which also added the caching rules to the entry skill so that the same mistake is not made again.

commit eeb7a7a19, lib/cache/decorators.py

A convention turned into a skill

A codebase-wide refactor that replaced improper uses of Any with typed aliases, and added the smarter-python-typing skill that keeps it that way.

commit bcd679acd

Skills as a product feature

The same Agent Skills format is a Smarter resource: a SkillPlugin gives an LLMClient a skill, fetched from GitHub through the hardened HTTP client. The SkillPlugin was itself designed and written by Claude Code.

plugin/plugin/skill.py, plugin/plugin/skill_sources.py

Attribution

The commit skill sets out who is the author, who is the co-author, and the Co-Authored-By trailers, and forbids the agent from committing at all.

smarter-git-commits/SKILL.md

Graded Assignments

Assignment 1: Instruction Analysis

Students summarize what CLAUDE.md and two skills instruct an agent to do, and explain the reason behind three of the rules, finding the code or incident that motivated each where they can.

Turn in: a one-page analysis.

Criterion

Pts

Exemplary

Developing

Accuracy

6

Rules summarized correctly.

Misread.

Reasons

8

Three rules explained, with evidence from the code or history.

Guessed reasons.

Insight

4

Notes which rules would help a human newcomer too.

None.

Clarity

2

Concise.

Rambling.

Assignment 2: Delegation and Review

Students submit the agent’s pull request (against their own fork) with their own review: what it got right, what it got wrong, what they changed, and the evidence that the tests and hooks pass.

Turn in: the pull request, the request they gave the agent, and a review of at least five comments.

Criterion

Pts

Exemplary

Developing

Request quality

4

Outcome and acceptance criteria stated.

Step-by-step or vague.

Review depth

8

Substantive comments on correctness, tests and fit with the code base.

Style comments only, or “looks good”.

Verification

5

Tests and hooks run by the student, results shown.

Took the agent’s word for it.

Honesty

3

Problems reported, not hidden.

Problems omitted.

Assignment 3: With and Without Skills

Students compare the agent’s work on the same task with and without the skills, on correctness, fit with existing patterns, tests and time.

Turn in: both diffs and a one-page comparison.

Criterion

Pts

Exemplary

Developing

Fair comparison

5

Same task, same model, fresh context each time.

Different tasks or carried-over context.

Criteria

6

Correctness, patterns, tests and time all compared.

One criterion.

Analysis

6

Links differences to specific skill content.

Describes differences only.

Conclusion

3

Honest, including if the skills made little difference.

Assumes the answer.

Capstone Projects

Students choose one. Capstones are due one week after the bootcamp.

Capstone A: A Feature Built with an Agent

Learning objective. Deliver a real feature with a coding agent while remaining its accountable author: specifying, reviewing, verifying and explaining every line.

Students use an agent to build a feature in their fork, for example a new management command, a new field with a console column, or a docs page with examples. They keep a log of the session, and must be able to explain every line in the final diff.

What students turn in:

  • A pull request against their fork with code, tests and documentation, passing tests and hooks.

  • The request and acceptance criteria they gave the agent, and a session log with their interventions and why.

  • A one-page reflection: what the agent did well, what it got wrong, and what they would do differently.

  • A ten-minute oral check with the instructor on any part of the diff.

How it is graded (100 points):

Criterion

Pts

Exemplary

Developing

Working feature

20

Correct, tested, documented, hooks pass.

Partly working.

Specification

15

Clear outcome and acceptance criteria.

Vague request.

Review and intervention

20

Log shows problems caught and corrected.

Accepted everything.

Understanding

30

Explains any line in the oral check.

Cannot explain key parts.

Reflection

15

Specific and honest.

Generic.

Capstone B: A Skill That Works

Learning objective. Improve an agent’s results by writing instructions, and prove the improvement with an experiment.

Students identify a class of mistake that agents make in Smarter (or in a project of their own), write a skill that prevents it, and run the same three tasks with and without the skill.

What students turn in:

  • The skill (SKILL.md and any references or scripts), following skills/README.md.

  • The three tasks, both sets of results, and a scoring table.

  • A two-page report on the effect and on what made the skill work, or not.

How it is graded (100 points):

Criterion

Pts

Exemplary

Developing

Problem

15

A real, recurring mistake, with examples.

Hypothetical.

Skill quality

25

Concise, specific, with a clear trigger description; follows the repository’s format.

Long and generic.

Experiment

25

Three tasks, fresh contexts, same model.

One task, or uncontrolled.

Results

20

Scored honestly.

Cherry-picked.

Report

15

Explains why it worked or did not.

Results only.

Further Study

  • Documentation: the Claude Code documentation, including its pages on memory (CLAUDE.md), skills, hooks and subagents, and the open Agent Skills format.

  • Essays: Anthropic’s Building effective agents, and its engineering blog’s posts on agentic coding best practices and context engineering.

  • Research: METR’s study Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity (2025), a randomized trial whose results surprised its authors, and a good starting point for a discussion of how to measure productivity honestly.

  • YouTube: Andrej Karpathy’s talk Software Is Changing (Again) (Y Combinator AI Startup School, 2025), and the talks on coding agents on the AI Engineer channel.

  • Podcasts: Latent Space, and The Pragmatic Engineer podcast and newsletter by Gergely Orosz, which reports on how engineering teams actually use AI.

  • Writing: Simon Willison’s weblog, which documents his own use of coding agents in detail, and the essays on blog.smarter.sh about building Smarter with agents.