Welcome to the Capstone Project course, where we'll bring together everything you've learned about Claude Code configuration, automation, and agent development. This is the first unit of the course, and we're going to start by planning and architecting a complete, real-world automation system.

Throughout this course, we'll build a Documentation Quality Automation System for a Docusaurus project. This isn't a toy example; it's a production-ready system that monitors documentation changes, runs quality checks, reviews pull requests automatically, and integrates with CI/CD workflows. Think of it as bringing together all the pieces you've learned into one cohesive, working system.

In this lesson, we'll focus on planning: understanding what we're building, how the components fit together, and what our final deliverables will look like. Good architecture starts with clear planning, so let's begin.

Before diving into our specific project, let's establish what makes a good automation system. An automation system isn't just a collection of scripts; it's a coordinated set of components that work together to solve a problem without manual intervention.

Effective automation systems share three characteristics. First, they respond to triggers: file changes, pull requests, scheduled times, or manual requests. Second, they follow consistent standards: the same checks run the same way every time. Third, they provide feedback: results are logged, posted to PRs, or sent to monitoring systems.

For documentation quality, automation is particularly valuable because it catches issues early. A broken link, missing SEO metadata, or unclear heading structure is easier to fix during development than after publication. Automated checks ensure every change meets quality standards before it reaches production.

Our capstone project is a Documentation Quality Automation System designed for a Docusaurus documentation site. When developers open pull requests with documentation changes, our system automatically reviews them for quality, standards compliance, and common issues.

Here's what the complete system will do:

This system solves a real problem: maintaining documentation quality at scale. As documentation grows, manual reviews become time-consuming and inconsistent. Our automation ensures every change is checked against the same standards, freeing reviewers to focus on content rather than formatting and structure.

Our system integrates five key components, each building on concepts from previous courses. Let's break down what each component contributes to the overall system:

Each component has a specific role. CLAUDE.md provides context and standards that guide the entire system. Skills define what good documentation looks like: quality metrics, SEO requirements, and link validation rules. Hooks provide immediate feedback during local development.

The Agent SDK orchestrates the full review process, using custom tools and GitHub integration. Finally, CI/CD ensures checks run automatically on every pull request.

Understanding how these components interact is crucial for building and debugging the system. Let's walk through what happens when a developer opens a pull request with documentation changes:

This flow shows the automation in action. The process starts with a trigger (the pull request), passes through automated analysis (the agent using Skills), captures operations for audit (Python callback hooks), and ends with actionable feedback (PR comments). Each step builds on the previous one, creating a pipeline that transforms documentation changes into quality reports.

Notice that the Agent SDK sits at the center of this flow. It receives the trigger from GitHub Actions, consults the Skills for standards, uses its Python callback hooks for logging, and posts results back to GitHub. This centralized orchestration keeps the system maintainable and extensible.

Let's look at how we'll organize all these components within the project. All project work will be done inside the cloned docusaurus/ directory. Claude will automatically locate and work within this directory structure. A clear file structure makes the system easier to understand, maintain, and extend:

This structure separates concerns cleanly. Configuration lives in CLAUDE.md and .claude/. The Skills are organized under .claude/skills/, each in its own directory with a SKILL.md file. The Agent SDK application has its own agents/ directory with Python code, dependencies, and tests.

CI/CD configuration stays in .github/workflows/ where GitHub expects it. The Dockerfile ensures the agent runs consistently across environments. Notice that we're not mixing agent code with documentation code, and we're not scattering configuration across the repository. Everything has a logical place, making the system predictable and maintainable.

Now that we understand the architecture, let's define exactly what we'll build. This checklist breaks down the project into concrete deliverables:

These five components represent about a week of focused development for an experienced developer, or a solid capstone project for this course. The configuration pieces (CLAUDE.md, Skills, hooks) establish standards and local automation.

The Agent SDK application provides the intelligence and orchestration. The GitHub Actions workflow ties everything together for continuous integration. Each deliverable builds on skills from previous courses while adding new integration challenges. For example, you've created Skills before, but now you'll design them to work together as a cohesive quality framework. You've written Agent SDK code, but now you'll integrate it with GitHub and CI/CD.

We've now mapped out the complete architecture for our Documentation Quality Automation System. We understand what we're building, why each component matters, how they interact, and where everything will live in the project structure.

This planning phase is crucial. With a clear architecture in mind, we can build each component confidently, knowing how it fits into the larger system. We've identified five main deliverables: project configuration through CLAUDE.md, three quality Skills, bash hooks for local automation, an Agent SDK application for orchestration, and a GitHub Actions workflow for CI/CD.

In the upcoming practice exercises, you'll start implementing these components step by step, beginning with the foundation and building up to the complete integrated system. Get ready to bring your Claude Code skills together into a production-ready automation pipeline!