Agentic Software Development: Four-Week Online Course

A four-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 twelve 30-minute recorded lectures and a 90-minute live session each week. Week 1 covers how agents work, week 2 delegation and review, week 3 instructions, skills and automation, and week 4 safety, measurement 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. Week 1 includes time for setup.

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 tasks of different sizes, and decide when not to delegate.

  3. Review and verify agent-written code and tests rigorously.

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

  5. Work safely with agents, including credentials, permissions and untrusted content.

  6. Measure the effect of agents on their own productivity honestly, and take responsibility for what agents 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 by the end of week 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, Markdown, and shell scripting (for hooks).

Schedule

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

Week

Item

Content

1

Lecture 1

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

1

Lecture 2

Context. What an agent can see, context windows, and why the code base matters more than the prompt.

1

Lecture 3

Agent-friendly code bases. Consistent structure, tests that run, and documented patterns, using Smarter as the example: the identical layout of the guardrail and secret apps, more than five thousand unit tests, the pre-commit hooks, typed aliases in lib/typing.py, and logs that name the code that wrote them.

1

Live session 1

Setup triage, then a first delegated task, live. Start Assignment 1.

2

Lecture 4

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

2

Lecture 5

Reviewing agent code. Weakened tests, swallowed errors, invented APIs and silent scope creep.

2

Lecture 6

When not to delegate. Tasks where the agent lacks the evidence, and debugging with an agent: a failing test first.

2

Live session 2

Review of Assignment 1. A live review of an agent’s pull request. Start Assignment 2.

3

Lecture 7

Instructions. CLAUDE.md: what belongs in it and what does not, read line by line against Smarter’s eight hard rules.

3

Lecture 8

Skills. Agent Skills, their triggers, 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.

3

Lecture 9

Automation. Hooks, subagents, and running agents in CI.

3

Live session 3

Review of Assignment 2. Skill writing workshop. Capstone proposals discussed. Start Assignment 3.

4

Lecture 10

Safety. Permissions, sandboxes, live credentials, secrets, and prompt injection through files, issues and web pages.

4

Lecture 11

Measuring productivity. What studies show, why self-reports mislead, and how to measure your own. Smarter’s own history as data: git shortlog and git log --shortstat before and after agents began authoring commits.

4

Lecture 12

Responsibility. Authorship, attribution, licenses, open source contributions, and the changing developer role.

4

Live session 4

Capstone presentations (about 6 minutes each, with 2 minutes of questions), and a course retrospective.

Assignments 1 to 3 are due before the next live session. Assignment 4 is due in the middle of week 4. The capstone proposal is due before Live session 3, and the capstone at the start of Live session 4.

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 CLAUDE.md and three skills, and explain the reason behind four rules, with evidence from the code or the history.

Turn in: a two-page analysis.

Criterion

Pts

Exemplary

Developing

Accuracy

6

Correct summaries.

Misread.

Reasons

8

Four rules, with evidence.

Guessed.

Insight

4

What would help a human newcomer too.

None.

Clarity

2

Concise.

Rambling.

Assignment 2: Delegation, Review and the Bug Hunt

Students delegate a change and review the result, then find the planted problems in three agent-written pull requests provided by the instructor, with tests that catch them.

Turn in: the request, pull request and review; and a report and tests for the three planted problems.

Criterion

Pts

Exemplary

Developing

Delegation and review

7

Clear request; substantive review; independent verification.

Vague request; “looks good”.

Planted problems

7

All three found and explained.

One.

Tests

6

Fail on the problem, pass when fixed.

Ineffective.

Assignment 3: A Skill with an Experiment

Students write a skill for a mistake they observed, and test it on two tasks with and without the skill.

Turn in: the skill, both sets of results, and a one-page report.

Criterion

Pts

Exemplary

Developing

Problem

4

Real and observed.

Hypothetical.

Skill

7

Concise, specific, clear trigger.

Generic.

Experiment

6

Controlled.

Uncontrolled.

Report

3

Honest.

Cherry-picked.

Assignment 4: A Safety Hook

Students write a hook that stops the agent from doing something dangerous in this repository, for example running a command that writes to real infrastructure, or committing a file that matches a secret pattern, and show it blocking the action while allowing normal work.

Turn in: the hook configuration and script, and a log showing a block and an allowed action.

Criterion

Pts

Exemplary

Developing

Threat

4

A real risk in this repository.

Hypothetical.

Works

7

Blocks the action, with a clear message to the agent.

Blocks nothing, or everything.

False positives

5

Normal work unaffected, tested.

Not tested.

Limits

4

Explains how it could be bypassed.

Claims to be complete.

Capstone Projects

Students choose one, propose it before Live session 3, and present it in Live session 4.

Capstone A: A Contribution Built with an Agent

Learning objective. Deliver a real contribution with a coding agent, to the standard of a reviewed open source pull request, while remaining its accountable author.

Students choose an open issue in Smarter (agreed with the maintainers in the issue first), build it with an agent, review and verify it themselves, and open the pull request upstream, disclosing how the agent was used.

What students turn in:

  • The upstream pull request, with code, tests and docs, passing CI.

  • The session log, with interventions and why.

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

How it is graded (100 points):

Criterion

Pts

Exemplary

Developing

Contribution quality

25

Ready to merge; CI passes; follows the project’s patterns.

Needs substantial rework.

Process

15

Discussed in the issue first; responds to review.

Unannounced; ignores review.

Review and intervention

20

Problems caught and corrected.

Accepted everything.

Understanding

25

Explains any line when asked.

Cannot explain key parts.

Reflection and presentation

15

Specific and honest.

Generic.

Capstone B: Making a Code Base Agent-Ready

Learning objective. Apply the practices that make Smarter effective for agents to another code base, and measure the effect.

Students take a project of their own or an open source project, and make it agent-ready: a CLAUDE.md, two or three skills, a safety hook, a test command that runs in one step, and fixes to the worst inconsistencies. They run the same three tasks before and after.

What students turn in:

  • A repository (or pull request) with the changes.

  • Before-and-after results on three tasks, with scores and time.

  • A three-page report, and a six-minute presentation.

How it is graded (100 points):

Criterion

Pts

Exemplary

Developing

Instructions

20

Concise CLAUDE.md and focused skills.

Long, generic text.

Code base changes

20

One-step tests, consistent patterns.

Instructions only.

Safety

15

A working hook for a real risk.

None.

Experiment

25

Controlled before and after.

Anecdotes.

Report and presentation

20

Honest about what helped and what did not.

One-sided.

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.