Lesson 3 – Agentic Coding using Claude Code

The Core Idea Behind Slash Commands

Claude Code is an agentic coding tool designed to function as a highly capable partner within the terminal. However, the effectiveness of any coding assistant depends largely on the quality of the initial prompt. Crafting a detailed, perfectly worded system prompt or instruction about code architecture, specific libraries, or linting rules can take as much time as writing the code itself. The fundamental friction in terminal-based AI agents is repetition. Without a mechanism to save and recall prompts, developers end up pasting the same long paragraphs of context or boilerplate requests for every new session. Slash commands solve this by transforming the terminal into an interface of programmable shortcuts, where the heavy lifting of prompt engineering happens only once. This session systematically explores this built-in feature, demonstrating how it converts the command-line experience from a blank slate into a customized control panel that remembers project-specific instructions across different coding tasks and sessions.

Understanding Built-in Commands

The environment ships with a set of built-in slash commands that provide immediate access to session management without any configuration. These commands act as the base operating system for the agent, allowing developers to clear context windows, view session histories, or manage memory with a few keystrokes. The demonstration in the lesson walks through each command and shows how a simple forward slash completely changes the interaction flow from a free-text chat to a discrete action menu. This immediate grammar shift is crucial because it signals to the developer that they are no longer generating content but executing an operation on the environment itself. By mastering these defaults first, the user understands the syntax structure required for custom workflows and sees how the interface differentiates between a regular message to the large language model and a meta-instruction intended for the Claude Code system. The concept of immutable system prompts versus session-scoped instructions becomes much clearer through these native shortcuts, setting the stage for building user-defined macros.

Moving from Repetition to Reusability

The problem that custom slash commands solve is almost universally experienced in software development: bootstrapping identical environments for new features, performing identical refactoring checks, or running the same multi-step diagnostic to understand a legacy codebase. Every manual retype of a long prompt that explains the desired folder structure, naming conventions, or obligatory error-handling patterns is a potential productivity leak. The lesson emphasizes that the primary innovation here is treating prompts as reusable assets rather than ephemeral chat messages. Once a developer takes a particularly effective prompt and turns it into a custom slash command, that prompt transitions from a one-time instruction into a persistent tool available at any point during the development lifecycle. This shift in mindset aligns the terminal agent more closely with traditional software tools where complicated logic is bundled once and called many times. The instructor highlights that this not only saves minutes on every invocation but also drastically reduces cognitive load, as the developer no longer needs to keep elaborate technical constraints active in their mind while working on a task.

Building Custom Slash Commands

Creating a custom slash command involves defining a markdown file where the file name becomes the invocation trigger and the content becomes the expanded instruction sent to Claude. The technical walkthrough explains that this file acts as a template system where static text and contextual information merge to form the final prompt. It is essential to understand the format guidelines and placement of these files within the project directory so Claude Code automatically discovers them. The lesson demonstrates how to craft these prompts specifically for a realistic project scenario, showing how something as simple as an instruction like get-context can inject the project overview, technology stack constraints, and persistent functional requirements into the model's context. The instructor meticulously covers naming conventions and the importance of clarity in the markdown body so that the slash command behaves predictably. The demonstration proves that this process is not just about shortening instructions but about standardizing output. By baking in tone, formatting, and explicit constraints into the command file, the developer enforces a style guide directly through the agent invocation, leading to responses that are immediately consistent and require minimal editing before integration.

Practical Integration and Workflow Design

A real-life example anchors the lesson by modeling a complete development workflow driven entirely by custom slash commands. Instead of manually describing the feature, testing requirements, and API contracts every time, the instructor builds a cycle where each stage of development gets its own dedicated command. One command initializes the task with full architectural context and generates boilerplate, another analyzes the generated output for potential security issues or missing edge cases following a documented checklist, and a third prepares commit messages or changelogs based on the session diff. This orchestrated approach effectively turns Claude Code into a project manager that follows a specific standard operating procedure. The walkthrough makes it clear that the real power of custom commands lies in chaining the model’s own analysis with human-defined process. Developers are shown how to first use the agent to understand errors or explore codebases and then capture that successful exploratory prompt as a permanent command for future teammates, effectively building a reusable knowledge base that lives inside the terminal rather than in disconnected documentation.

Strategy and Best Practices

Establishing a productive system relies on knowing when to use a slash command, how to name it, and how to prevent command sprawl. The lesson offers practical guidelines that revolve around discoverability and maintenance. Because these commands are just text files, they should be version-controlled alongside the source code. This means that when a developer joins a project, they instantly gain access to the historical prompt engineering that the team has refined over time. The instructor advises against creating single-use, hyper-specific commands that clutter the namespace and instead recommends focusing on recurring analytical loops like code reviews, onboarding summaries, or dependency audits. The discussion also covers the differentiation between using slash commands for deterministic operations and keeping the standard conversational flow for open-ended exploration. This creates a disciplined environment where the developer controls the context window more aggressively, preventing the agent from drifting while still allowing full creative freedom when needed.

When to Apply These Tools

The final segment ties the concepts together by helping developers identify the exact moment in their work when a slash command becomes the right solution. The rule of thumb is elegantly simple: if a prompt is used three times across different sessions or projects, it deserves to become a permanent, versioned asset. The lesson connects this to larger themes of developer velocity and codebase consistency, explaining that teams using consistent agent instructions produce more predictable merge requests. By the end of the session, the viewer should view Claude Code not just as a chat partner but as a programmable layer where their own expertise and rules drive the artificial intelligence. The ultimate recommendation is to start small by codifying one repetitive task, observe the time and quality improvement, and then progressively build a library of intelligent shortcuts that make the terminal feel truly bespoke to the developer’s specific technical stack.