Welcome to the final unit of the Capstone Project course! Over the past two units, we've architected and implemented a complete Documentation Quality Automation System. We've written configuration files, created specialized skills, and developed an Agent SDK application.

Now comes the critical phase: comprehensive end-to-end testing and documenting what we've built. This lesson guides you through testing, shows you how to validate that all components integrate correctly, and helps you create a complete system inventory. We'll run a real-world workflow to review documentation, verify each integration point, and document the entire system for future reference.

By the end of this unit, you'll have confidence that your system works as designed and a clear understanding of what you've accomplished. Let's begin by establishing our testing approach.

Testing systems that integrate AI requires a different mindset from traditional software testing. While we can't predict exact AI outputs, we can verify that our automation pipeline works correctly and produces useful results.

Our testing strategy focuses on three key areas:

• Integration points: Verifying that components communicate correctly (CLAUDE.md provides context, skills load properly, and the Agent SDK orchestrates correctly).
• Workflow execution: Confirming the complete process runs from start to finish without errors.
• Output quality: Ensuring the bot produces actionable feedback that meets our documentation standards.

Rather than asserting specific text in AI responses, we validate that the system behaves correctly: files get reviewed, reports get generated, costs get tracked, and the entire workflow completes successfully. This practical approach gives us confidence without brittle test assertions.

We start our test by running the agent on a sample documentation file to see how all components work together.

We deliberately create a documentation file with quality issues to verify our system catches them. This file will have a missing meta description and a broken link, both of which are violations of our quality standards. By introducing known problems, we can confirm that our bot identifies them correctly.

As the bot executes, watch how it uses the Skills we created:

These log entries show the agent applying each of our three skills in sequence. The docs-quality skill examines overall structure, the seo-standards skill checks for meta descriptions and heading hierarchy, and the link-validation skill verifies external URLs. This confirms our skills integration works correctly and gives us visibility into the agent's decision-making process.

After processing, the bot generates a detailed report identifying the intentional issues we introduced:

The report shows three findings with different severity levels. The missing meta description gets a warning (⚠️) since it affects SEO but doesn't break functionality. The broken link receives an error (❌) because it creates a poor user experience. Code blocks pass (✓) because they include proper language tags. The cost tracking helps us monitor API usage for budgeting purposes.

Based on the bot's feedback, we fix the identified issues:

We update the file to address both the broken link and the missing meta description. This demonstrates the practical value of our automation: clear, actionable feedback that developers can immediately address.

After fixing the issues, we verify our changes align with the quality standards:

The verification confirms that our fixes address the specific issues the bot identified. The meta description now meets the 150-160 character requirement from seo-standards, and the external link uses a valid URL format that passes link-validation checks. The code blocks that were already correct remain properly formatted.

This demonstrates the iterative nature of our system: developers receive feedback, make improvements, and verify that the issues are resolved. The quality standards defined in our Skills provide clear targets for what "resolved" means — no guesswork, just concrete criteria to meet.

With testing complete, let's document what we've built. We start with our configuration components:

These foundational pieces establish how our system understands the project. CLAUDE.md provides project context and documentation standards. The three skills encode specific quality requirements: docs-quality, seo-standards, and link-validation.

Our Python application forms the core of the automation system:

The Agent SDK application orchestrates the entire review process. It integrates with our three skills to apply quality standards and implements robust error handling to gracefully manage API failures or configuration issues.

We've validated the system through comprehensive testing:

Local testing confirmed that individual components work correctly. End-to-end testing demonstrated the full cycle from file review to actionable feedback. Production readiness includes proper environment variable management, comprehensive logging for debugging, error handling for resilience, and clear documentation for maintenance.

Our complete system comprises seven interconnected components:

Each component serves a specific purpose in the larger system. CLAUDE.md establishes what the project is about. Skills define quality requirements. The Agent SDK application orchestrates reviews. Bash Hooks enable local pre-commit checks. SDK Hooks integrate with version control. CI/CD automates quality checks in pull requests. Docker provides consistent deployment. Together, these 500 lines of configuration and code create a powerful, production-ready automation system.

The power of this system comes from how it integrates features from across the course path:

This capstone project brings together everything from the learning path. CLAUDE.md from Course 1 provides project context. Hooks from Course 2 enable automation triggers. Skills from Course 3 encode domain knowledge. The Agent SDK from Course 4 orchestrates AI-powered workflows. By combining these features, we've built something more powerful than any single component could achieve alone.

We've now completed the full journey from planning to implementation to testing and documentation. You've built a production-ready system that automatically maintains documentation quality, provides actionable feedback to developers, and can be integrated into development workflows.

This system represents real-world AI automation: not just a clever demo, but a practical tool that saves time, improves quality, and scales across teams. The testing we performed confirms everything works together correctly, while our documentation ensures the system remains maintainable.

Most importantly, you've gained hands-on experience combining multiple AI tooling features into a cohesive solution. These skills transfer directly to other automation challenges: code review bots, automated testing systems, intelligent deployment pipelines, and more. Now it's time to apply what you've learned in the practice exercises, where you'll test the complete system yourself and verify that every integration point works exactly as designed!