Lesson 4 – Claude Code 101

Prompting Claude Code for the first time

The initial interaction with any new development tool can feel like a leap of faith, and writing a first prompt in Claude Code is no exception. For many, the blank terminal represents a shift from a graphical interface to a text-based command center, which immediately triggers questions about the right way to speak to the agent. The core principle introduced here is not about mastering a rigid syntax but about providing clear, natural language context. This makes the transition from an integrated development environment to an agentic terminal feel less like programming a robot and more like assigning a task to a knowledgeable colleague. The goal is to demystify the process by demonstrating a practical, real-world scenario that resonates with front-end developers and engineers alike, showing them how to translate a feature request into a concrete code change.

A practical walkthrough with dark mode

The most effective way to build confidence is through a familiar task, which is why the lesson showcases the implementation of a dark mode toggle on an existing project. By describing the current codebase state and the desired visual outcome, the agent can analyze the project structure, identify the relevant style sheets, and propose the necessary modifications. This example is particularly effective because it touches on multiple layers of software development in a single prompt: understanding the application’s state management, modifying component styles, and ensuring that the preference persists across different parts of the interface. It illustrates that the agent is not just outputting text predictions but is capable of reading files, understanding the relationships between them, and writing syntactically correct code that integrates seamlessly into a larger system.

How Claude Code understands your project

Under the hood, the agent relies on its ability to read and map the project’s context before taking action. Instead of requiring users to reference specific file paths with every command, a high-level directive allows the agent to explore the directory tree and infer where the changes should live. This process mirrors the cognitive steps a senior developer takes when sitting down to a new story: surveying the landscape, reading the relevant files, and then drafting a scope of work before writing a single logical line. The lesson makes this invisible step visible by encouraging users to notice how the agent navigates the repository. When a user asks Claude Code to implement a feature, the tool confirms its understanding of the request and the files it intends to modify, which is a crucial moment of trust-building for anyone nervous about letting an AI execute changes on their machine.

Understanding approval mode versus auto-accept

A critical concept that separates safe experimentation from rapid-fire iteration is the distinction between approval mode and auto-accept. Approval mode is the default safety net, designed to pause and present a diff of the proposed changes before any byte is written to disk. This gives the developer a moment to review the logic, spot potential edge cases, and verify that the agent is not making unwarranted assumptions about unrelated parts of the codebase. It effectively functions as a mandatory code review loop, ensuring that the human remains firmly in the decision-making driver’s seat during the initial phases of a complex task.

The shift in agency during execution

Switching to auto-accept mode fundamentally changes the tempo of the interaction by removing the confirmation step between the prompt and the execution. This mode is intended for scenarios where the developer trusts the tool’s judgment implicitly, often for repetitive refactors, generating boilerplate test files, or styling adjustments that have a low risk of breaking critical business logic. Understanding that these modes can be toggled based on the risk level of the task is essential for a productive workflow. The lesson emphasizes that the standard practice should always begin with approval mode because seeing the agent’s plan before it acts is how a developer builds the intuitive trust required to eventually speed up the process with auto-accept. This graduated approach prevents the overwhelming sensation of losing control over the codebase while still offering a pathway to extreme velocity when it is safe to do so.

Managing expectations with initial prompts

A subtle but important theme in this beginner-level instruction is the shift from exact instructions to descriptive goals. The user does not need to write a line of CSS or a JavaScript event listener; they simply explain the user experience they want to create. The agent then handles the translation from design intent to technical implementation. This is a mental model shift away from deterministic keystroke macros and toward probabilistic but highly informed collaboration. It also sets the stage for understanding that the quality of the output is heavily dependent on the specificity of the natural language description, encouraging users to be verbose about what they want to achieve, not necessarily how to achieve it architecturally.

Taking the next logical step

The natural trajectory from this lesson is to move from a single, isolated prompt to a more complex, multi-step interaction where the agent runs commands, interprets their output, and adjusts its approach accordingly. The course structure promises a natural progression that deepens the developer’s understanding of how to maintain a productive, long-running coding session with the agent. By completing this initial walkthrough, a user is equipped with the fundamental mental model necessary to explore more advanced customization and hook into the full potential of the terminal-native coding assistant without feeling adrift in the command line.