CodeVerse Creatives
Esc
Claude & AI-Assisted Development Syllabus / Module 5 · Capstone / Week 14

Week 14: Capstone — Ship a Claude-Powered Agent, End to End

No new concepts this week — this is where the last thirteen weeks come together. You'll pick a real project, design its architecture around the Messages API and tool use, build it with the guardrails and verification habits from every earlier module, and write it up the way you'd present it to an employer or a teammate. The finished result is a portfolio piece: something you built end to end and can explain every decision behind.

Module 5 of 14 Week 14 of 14 ~4–6 Hours Capstone Project

By the end of this week, you'll be able to

  • Design and justify an architecture combining the API, tool use, and a real interface
  • Ship a working project someone else could actually run and try
  • Write up your design decisions clearly enough to defend them in an interview
1 Picking a Project 2 Architecture 3 Building It 4 Writing It Up 5 Capstone Project 6 Course Recap

1. Picking a Project

Pick something you can genuinely finish, not the most ambitious idea you can think of. Any of these combine the whole course; adapt one, or bring your own as long as it hits the same shape:

  • A research assistant agent. Given a topic, breaks it into sub-questions (orchestrator-worker, Week 13), researches each, and produces a cited report — a real application of grounding (Weeks 3–4) at agent scale.
  • A support-ticket triage agent. Classifies incoming tickets, drafts a response, and escalates via a tool call to a (real or mocked) ticketing system — a strong fit for Week 9's model-tiering (cheap model for the common case, escalate the hard ones).
  • A codebase Q&A tool. Answers questions about a real repository using tool use to read files on demand, exposed as a CLI or as a Claude Code custom command/MCP server — directly extends Weeks 10–11.

Whichever you pick, it needs to actually use the Messages API with real tool calls — not just a wrapped prompt with no tools at all — since the tool-use loop is the mechanism the whole agents module has been building toward.

2. Architecture: API + Tools + Interface

Every version of this project shares the same underlying shape, assembled from pieces you've already built individually across the course:

the shape, regardless of which project you pick
Interface (CLI, simple web UI, or a Claude Code command/MCP server)
        |
        v
Agent loop: Messages API + system prompt (Weeks 3, 6) + tools (Week 7)
        |
        v
Real tool functions: your data, your actions, real error handling
        |
        v
Guardrails: max-step limit, and a human-approval checkpoint for
           anything risky (Weeks 10, 13)

Before writing code, decide and write down: which model tier (Week 1, 9), whether you need streaming (Week 6) or caching (Week 9), and which of Week 13's patterns (a straightforward ReAct loop is enough for most capstone-scale projects) fits your chosen task.

3. Building It: A Practical Checklist

Build in this order — it mirrors the whole course's progression on purpose:

  • Start with the simplest working version: one tool, one straight-line path, no guardrails yet. Get that talking to the real API correctly first.
  • Add your second tool and confirm the multi-step loop actually chains correctly (Week 7).
  • Add the max-step guardrail and, if the project has a risky action, a human-approval checkpoint before it (Week 13).
  • Add real error handling in your tool functions — structured errors, not silent failures (Week 7).
  • If any output should be grounded in a real source, require and verify a citation (Weeks 3, 4, 8).
  • Wire up the interface last, once the underlying agent loop actually works from the command line.

4. Writing Up Your Capstone

A short README, written the same way Week 12 taught you to draft a PR description — grounded in what you actually built, not an idealized version of it. Cover:

  • What it does, in 2-3 sentences a non-technical person could follow.
  • Your architecture decisions: which model tier and why, which pattern from Week 13, and why an agent was the right shape for this task (not over-engineering, per Week 13's checklist).
  • What you'd improve with more time — a good sign you understand the tradeoffs you made, not just that you finished.

5. Capstone Project

Capstone

Ship a working Claude-powered agent with real tool use

Everything from Sections 1–4, built out completely.

Requirements:

  1. Pick one of the project ideas above (or your own of similar scope) and build it on the Messages API with at least 2 real tools.
  2. Give it a working interface someone else could actually run — a CLI is fine; a simple web UI is a nice bonus.
  3. Add at least one guardrail: a max-step limit, and/or a human-approval checkpoint before a risky action.
  4. Ground at least one output in a real source with a verifiable citation, per Weeks 3–4 and 8.
  5. Write a short README covering what it does, your architecture decisions, and what you'd improve next.
What "done" looks like

Something you can run right now and hand to someone else to try, a README that explains your decisions rather than just listing features, and at least one place where you can point to a guardrail and say exactly what it prevents. That combination is what makes this a portfolio piece rather than a tutorial exercise.

6. Course Recap

Fourteen weeks, five modules that build on each other:

  • Weeks 1–3 — how Claude actually works, and the prompting techniques that reliably get what you want from it.
  • Weeks 4–5 — using claude.ai as a real work surface: Projects, long documents, iteration, and knowing what it's actually good for.
  • Weeks 6–9 — building with the Anthropic API: requests, tool use, multimodal input, and running it efficiently at cost and scale.
  • Weeks 10–12 — Claude Code: install, permissions, CLAUDE.md, hooks, subagents, MCP, and real engineering workflows.
  • Weeks 13–14 — what actually makes something an agent, the patterns behind one, and shipping a real one yourself.

That's the full path from "chatting with Claude" to building with it. If you want the theory underneath the model itself — how transformers and training actually work — the LLM & ML course picks up exactly where this one treated the model as a given.

← Previous Week 13: Designing AI Agents with Claude Next Full Syllabus — Course Complete