Lesson 10 – Agentic Coding using Claude Code

The Core Limitation of General-Purpose AI

Agentic coding tools have transformed how developers work, but they often hit a wall when faced with specialized, repeatable tasks. A general-purpose AI assistant can generate a one-off script to sort JSON data, but it struggles to consistently apply your team’s specific UI framework, API conventions, or testing protocols across dozens of files. The reasoning is simple: a general AI lacks the persistent, narrow context required to become a task-specific expert. When you write a prompt, you are starting from scratch every time, injecting the same long instructions manually. This is where the concept of 'skills' inside tools like Claude Code becomes a paradigm shift.

This lesson from CampusX unpacks exactly this problem. The session, led by Nitish Singh, introduces skills not as a minor feature, but as the fundamental building block for turning a chat-based AI into an expert agent that can execute complex, multi-step workflows. A skill is, in essence, a portable, reusable knowledge unit that teaches an AI precisely how to behave in a specific domain. Think of it less as a prompt and more as a micro-firmware update for your AI assistant. By the end of this deep dive, you will understand why raw prompting fails at scale and how a structured approach using metadata, resources, and progressive disclosure completely solves the reliability issue.

Why Prompts Fail in Repeated Workflows

The video begins by tackling a universal pain point for developers: the fragility of long, complex prompts. A typical prompt for a task like 'generate a React form with our design system' can easily balloon to hundreds of words. You need to specify the styling library, the folder structure, the form validation logic, and the accessibility standards. The first friction point is manual effort; pasting these giant prompts repeatedly kills productivity. The second, more dangerous point is inconsistency. AI models are probabilistic, and a small alteration in wording can lead to a divergent architectural choice.

The third failure point is context starvation. A single prompt window has a limited context size. When you load it with massive instructions, you crowd out the actual codebase you need the model to process. The lesson demonstrates that prompts fail because they treat every instance as a greenfield project. They don’t learn from the last run. A skill, conversely, acts as a sealed expert capsule, loaded only when needed. It ensures consistency because the instructions remain static between usages. This distinction between ephemeral guidance and persistent expertise is the conceptual backbone of the entire session.

Understanding the Skill Architecture

Structurally, a skill is far more than a text file. The video maps out a standardized folder system that every effective skill must follow. The heart of the skill is the `skill.md` file, which holds the natural language instructions. However, a bare text file is insufficient for dynamic workflows, which is why the architecture crucially incorporates YAML metadata. This metadata tells the host tool what triggers the skill, what version it is, and what high-level purpose it serves, without having to read the entire file.

Surrounding the core markdown file is a `resources` directory. This is where the specific, heavy files live, such as boilerplate code templates, configuration files, or even compressed documentation. The brilliance of this structure is that it mirrors how human teams operate. A human expert doesn’t hold every PDF in their head; they know where the reference files are and when to consult them. This folder-based isolation solves a major security and reliability issue as well. By isolating skill dependencies, you prevent library conflicts between a Python skill and a JavaScript skill running in the same project environment.

Progressive Disclosure and The Loading Mechanism

One of the most technically sophisticated concepts covered in this class is 'progressive disclosure.' When dealing with hundreds of skills, you cannot load every single instruction into the AI’s active memory at all times. Doing so would immediately hit token limits and confuse the model. The video explains the loading mechanism as a three-stage intelligent funnel. First, the system sees only the name and metadata of available skills. This takes up almost no context.

When the user’s intent matches a trigger, the system loads the `skill.md` description to confirm alignment. Only at the final stage, when the skill is actually invoked, are the heavy resource files and full templates loaded into memory. This on-demand mechanism is the secret sauce of agentic specialization. It allows an AI to theoretically be proficient in thousands of skills while utilizing the context window of just one. The lesson emphasizes that this is the engineering pattern that separates 'having a good prompt library' from 'building an AI agent system.'

Personal Versus Project-Level Skills

The session draws a clear operational line between two classes of skills: personal and project-scoped. Personal skills are your own toolkit. These might include a skill that generates your preferred Git commit message format, or a skill that scaffolds screenplays in your unique narrative voice. These skills live globally on your machine and are always available to the Claude terminal. They represent individual acceleration.

Project skills, on the other hand, are checked into the repository root. They are collaborative contracts. When a new developer clones a codebase equipped with skills, the AI is automatically trained on the project’s specific architecture the moment the environment starts. The video uses a practical example from the 'Spendly' financial tracking app repository. By placing skills in the project folder, the team enforces a standardized way of building API endpoints or React components. This ensures that human code from Bob and AI-generated code from the assistant are indistinguishable in pattern and quality.

The Skill Creation Lifecycle

Rather than just discussing theory, the lesson outlines a robust lifecycle for skill creation. The workflow is: Identify, Create, Test, and Iterate. Identification is often the hardest step. Nitish guides viewers to look for repetitive 'chunks' of work that require high cognitive load but tightly bounded rules. If you find yourself manually linting a specific security rule five times a day, that is a prime candidate for a skill.

The creation phase involves writing the `skill.md` and setting up the templates. The video details how to use Claude itself to create these skills, a form of meta-agentic programming where the AI helps scaffold the instructions that will later govern it. The testing phase is critical; you must run the skill against edge cases to ensure the model isn’t getting confused by vague pronouns in the markdown. Iteration closes the loop, as skills must evolve alongside the codebase. This lifecycle forces a mindset shift from 'writing a quick script' to 'curating a long-term, reusable asset.'

Practical Application in the Spendly Project

To ground these concepts, the video moves into a practical implementation for the Spendly app. The challenge is a classic front-end task: building a profile page. Using a generic prompt, the AI might generate a functional page, but it might use raw HTML instead of the established React component library, or it might violate the project’s state management pattern.

The live demonstration shows how a custom skill fixes this. The skill file pre-loaded the tech stack constraints, the specific UI library (likely Material-UI or a similar component set based on the context of the channel’s previous tutorials), and the routing conventions. The execution sequence is precise: spec creation, planning, and then code generation. The result is a profile page UI that slots into the existing codebase without requiring manual refactoring. It is a complete, ready-to-merge feature generated in under a minute, highlighting the raw efficiency gain of bottom-up skill curation.

Revolutionizing Developer Workflows

Ultimately, this lesson positions agentic coding skills as the cornerstone of modern collaborative software engineering. The transition from prompt engineering to skill engineering is a massive leap in maturity for AI-driven development. Prompts are ephemeral; skills are persistent. Prompts suggest; skills enforce. By mastering the folder structure, metadata, and disclosure mechanisms explained here, developers can build a private army of specialized AI experts.

The video leaves the audience with a powerful mental model: stop treating your AI as a general consultant and start treating it as a team of highly specialized subordinates, each trained meticulously through a skill. For anyone looking to scale their AI productivity past novelty scripts and into production-grade software, understanding this lesson’s framework is essential. It represents the standardization of AI expertise into auditable, shareable, and measurable units of work.