Agentic Software Development: Two-Week Online Course

A two-week online course 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. There are six 30-minute recorded lectures and a 90-minute live session each week. Week 1 covers how agents work and how to delegate and review, and week 2 covers instructions, safety and responsibility. See Course Formats and Grading for the format, 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.

Deployment

Each student runs Smarter from source, with a fork on GitHub and a coding agent installed, before Live session 1.

Workload

3 hours of instruction and 4 to 6 hours of assignments each week.

Cost

A coding agent subscription or API usage for each student, plus small model charges from Smarter’s tests.

Learning Objectives

By the end of the course, students can:

  1. Explain how coding agents work, and what makes a code base agent-friendly.

  2. Delegate broad, bounded tasks with clear acceptance criteria.

  3. Review agent-written code and tests critically, and verify them independently.

  4. Write instructions and skills that improve an agent’s results, and measure the effect.

  5. Work safely with agents, and take responsibility for what they produce.

Technical Prerequisites

  • Required: Python or JavaScript, well enough to review a pull request.

  • Required: Git and GitHub, including code review.

  • Required: the command line, and Docker basics.

  • Required before Live session 1: Smarter installed from source, and a coding agent working in the repository.

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

  • Helpful: automated testing, and Markdown.

Schedule

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

Week

Item

Content

1

Lecture 1 (30 min)

What a coding agent is. A model in a loop with tools, context and permissions.

1

Lecture 2 (30 min)

How you ask. Outcomes, evidence, acceptance criteria and the pattern-first workflow. Agentic Development.

1

Lecture 3 (30 min)

Reviewing agent code. Weakened tests, swallowed errors, invented APIs, and verifying independently.

1

Live session 1 (90 min)

The instructor delegates a task live and reviews the result with the class. Pairs then delegate one of their own. Start Assignment 1.

2

Lecture 4 (30 min)

Instructions and skills. CLAUDE.md, Agent Skills, and how Smarter’s skills grew from repeated mistakes, such as the caching rules added by commit eeb7a7a19. The same format as a product feature: the SkillPlugin.

2

Lecture 5 (30 min)

Safety. Permissions, sandboxes, live credentials (and why Smarter’s smarter-infrastructure-safety skill fakes every cloud call in tests), secrets and prompt injection through files.

2

Lecture 6 (30 min)

Responsibility. Authorship, attribution, licenses, and the changing developer role.

2

Live session 2 (90 min)

Capstone presentations (about 5 minutes each, with 2 minutes of questions).

Assignment 1 is due at the end of week 1, Assignment 2 in the middle of week 2, and Assignment 3 and the capstone at the start of Live session 2.

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: Delegation and Review

Students delegate a broad, bounded change to the agent, and review the resulting pull request as a colleague’s.

Turn in: the request, the pull request against their fork, and a review of at least five comments with test and hook results.

Criterion

Pts

Exemplary

Developing

Request

4

Outcome and acceptance criteria.

Steps or vague.

Review

8

Substantive.

“Looks good”.

Verification

5

Run by the student.

Agent’s word.

Honesty

3

Problems reported.

Omitted.

Assignment 2: The Bug Hunt

The instructor provides three agent-written pull requests, each with a planted problem (a weakened assertion, a swallowed exception, an invented function). Students find and explain each problem, and write the test that would have caught it.

Turn in: a short report for each pull request, and the tests.

Criterion

Pts

Exemplary

Developing

Problems found

8

All three.

One.

Explanation

6

Why it is wrong and what it would cause.

Named only.

Tests

6

Fail on the planted problem, pass when fixed.

Missing or ineffective.

Assignment 3: With and Without Skills

Students compare the agent’s work on the same task with and without the skills.

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

Criterion

Pts

Exemplary

Developing

Fair comparison

5

Same task and model, fresh context.

Uncontrolled.

Criteria

6

Correctness, patterns, tests and time.

One.

Analysis

6

Linked to skill content.

Describes only.

Conclusion

3

Honest.

Assumed.

Capstone Projects

Students choose one, and present it in Live session 2.

Capstone A: A Feature Built with an Agent

Learning objective. Deliver a real feature with a coding agent while remaining its accountable author.

Students build a feature in their fork with an agent, keep a session log, and must be able to explain every line.

What students turn in:

  • A pull request with code, tests and docs, passing tests and hooks.

  • The request, acceptance criteria and session log.

  • A one-page reflection, and a five-minute presentation with live questions on the diff.

How it is graded (100 points):

Criterion

Pts

Exemplary

Developing

Working feature

20

Correct, tested, documented.

Partly working.

Specification

15

Clear criteria.

Vague.

Review and intervention

20

Problems caught and corrected.

Accepted everything.

Understanding

30

Explains any line when asked.

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.

Students write a skill for a recurring mistake, and run three tasks with and without it.

What students turn in:

  • The skill, following skills/README.md.

  • Tasks, results and scores.

  • A two-page report, and a five-minute presentation.

How it is graded (100 points):

Criterion

Pts

Exemplary

Developing

Problem

15

Real and recurring.

Hypothetical.

Skill quality

25

Concise, specific, clear trigger.

Long and generic.

Experiment

25

Controlled, three tasks.

Uncontrolled.

Results

20

Honest.

Cherry-picked.

Report and presentation

15

Explains why.

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.