Lesson 8 – Agentic Coding using Claude Code

Starting the Expense Tracker Project

This practical coding session demonstrates how to kick off a real-world project using an agentic coding approach. The goal is to build an expense tracker, beginning with the foundational step of setting up a database. Rather than diving straight into writing code, the video emphasizes a structured, spec-driven development workflow supported by Claude Code. This method treats the AI as an active collaborator capable of planning, executing, and validating changes under human guidance. The session walks through every phase, from branching in Git to opening a pull request, showing how to integrate Claude Code into a professional software development lifecycle.

Understanding Spec-Driven Development

Central to the approach is Spec-Driven Development, a practice where a detailed specification document guides all implementation work. The spec acts as a single source of truth that defines what needs to be built, the acceptance criteria, and the technical constraints. In this workflow, the developer first creates a comprehensive spec document for the database setup task. This document instructs Claude Code on the exact database schema, tables, and relationships needed. By front-loading the requirements into a clear, text-based document, the ambiguity in AI-assisted coding is drastically reduced, leading to more predictable and accurate code generation.

Setting Up the Environment and Scope

The video begins with a quick recap of the series before defining the immediate goal: database initialization. The instructor demonstrates proper Git hygiene by creating a new feature branch from the main branch. This isolates the upcoming changes and simulates a standard team-based workflow. With the repository prepared, the focus shifts to crafting the spec document. This document is not just a rough sketch; it includes specific instructions, desired outcomes, and testable acceptance criteria. By investing time in this planning phase upfront, the subsequent steps become almost mechanical, allowing Claude Code to operate with a high degree of autonomy.

Leveraging Plan Mode for Architecture

A key technical highlight is the introduction of Claude Code's Plan Mode. Instead of immediately generating code, Plan Mode acts as a purely analytical phase. It reads the spec document and generates a detailed implementation plan. This plan breaks down the high-level goal into discrete, ordered steps, identifying potential file changes, module dependencies, and logical sequences. The video stresses the critical role of this intermediary step, as it serves as a validation checkpoint for both the AI and the developer. The plan is reviewed and approved before a single line of code is written, ensuring the final output aligns with architectural best practices and project requirements.

Execution, Validation, and the Code Review Loop

Once the implementation plan is approved, execution mode takes over. Claude Code systematically follows the plan, writing the necessary scripts and configuration files for the database. The true power of the spec-driven approach shines during the validation phase. The automatically generated code is tested against the pre-defined acceptance criteria from the original spec document. This creates a tight feedback loop, acting like an automated code review that verifies functional correctness. If any test fails, the loop iterates until the code fully satisfies all specified requirements, ensuring that the AI-generated code is not just syntactically correct but functionally robust.

Completing the Git Workflow

After successful validation, the video culminates in a complete Git-based software delivery workflow. The instructor stages the generated files, creates a meaningful commit message, and pushes the feature branch to the remote repository. Finally, a pull request is opened, merging the database setup into the main codebase. This demonstrates that Claude Code can be integrated seamlessly into collaborative development practices without skipping crucial steps like code review and version control. It reinforces that agentic coding is not about replacing Git discipline but about accelerating the steps within that disciplined framework.

Optimizing Planning with Model Selection

The session also provides strategic insights into best practices for using Plan Mode effectively. It advises on model selection, noting that more capable models with extended thinking capabilities tend to produce superior, more robust plans. The discussion includes tips for writing clearer spec documents to minimize back-and-forth and improve plan quality. By treating the planning phase as a distinct, non-negotiable step rather than an optional add-on, developers can handle larger, more complex feature implementations with greater confidence and fewer hallucinations or logical errors from the AI.

Practical Takeaways for Agentic Coding

The core takeaway is a repeatable, dependable pattern for agentic coding. The workflow—specify, plan, execute, validate, and commit—transforms coding with AI from a simple autocomplete feature into a high-level engineering partnership. This episode equips developers with a mental model for scaling their use of AI tools beyond small scripts to full project modules. By combining a rigorous specification process with Claude Code's analytical planning capabilities, teams can achieve a level of consistency and quality that mirrors traditional software engineering, all while significantly accelerating the development cycle.