New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Module 1

by brevdev in brevdev/workshop-build-an-agent

This skill should be used when a learner is working through Module 1 ("Build an Agent") of the Build-an-Agent workshop and wants help understanding the concepts, notebooks, or code — e.g.

Apache-2.0Auto-check passedAI & LLM Engineering

Install Module 1

skills CLI
$ npx skills add brevdev/workshop-build-an-agent --skill module-1 -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install brevdev/workshop-build-an-agent module-1 --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/brevdev/workshop-build-an-agent.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/module-1 .claude/skills/module-1 && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
module-1
GitHub stars
143
Token cost
~2.7k tokens
SKILL.md length
1,266 words
Files
7 (incl. references)
Skills in repo
11
Repo updated
First seen
Licence
Apache-2.0

At a glance

This skill should be used when a learner is working through Module 1 ("Build an Agent") of the Build-an-Agent workshop and wants help understanding the concepts, notebooks, or code — e.g.

  • Works in 8 steps: Never complete an exercise or write the… → Give graduated hints, smallest first.… → Don't act in ways that replace… → …
  • Tasks that involve Building AI agents
  • SKILL.md covers Your role, Non-negotiable tutoring rules, Module 1 at a glance and Key concepts (quick recall), plus 6 more sections
  • Reaches integrate.api.nvidia.com; needs NVIDIA_API_KEY and TAVILY_API_KEY

What it does

Module 1 is an agent skill from brevdev/workshop-build-an-agent. This skill should be used when a learner is working through Module 1 ("Build an Agent") of the Build-an-Agent workshop and wants help understanding the concepts, notebooks, or code — e.g. "/module-1 what are agents?", "/module-1 explain the ReAct pattern", "help me with the docgen client exercise", "why use an agent instead of a single LLM call?", "my introtoagents notebook errors", "I'm stuck on Part 4 routing". It turns the agent into a Module 1 learning assistant (tutor) that explains concepts in the…

Its SKILL.md is about 2.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including reference files (for example `references/concepts.md`, `references/diagrams.md` and `references/exercises.md`).

It sits in AI & LLM Engineering, covering Building AI agents, Tutoring and explanations and React components. It works with LangChain, NVIDIA AI Platform and Tavily. The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Building AI agents
  • Tasks that involve Tutoring and explanations
  • Tasks that involve React components

Example prompts

  • “Build an Agent”
  • “/module-1 what are agents?”
  • “/module-1 explain the ReAct pattern”
  • “/module-1”

Requirements

  • Docker
  • A credential in NVIDIA_API_KEY
  • A credential in TAVILY_API_KEY

Workflow steps

8 steps, taken from the first numbered list in SKILL.md.

  1. Never complete an exercise or write the learner's solution. Every blank in
  2. Give graduated hints, smallest first. Start by asking what they've tried.
  3. Don't act in ways that replace understanding. Don't run exercise cells for
  4. Separate "exercise" from "environment". Filling in exercise code = guide
  5. Ground everything in the real module; never fabricate. Base answers on the
  6. Don't spoil later modules. If a question jumps ahead (RAG, evaluation,
  7. Verify, don't rubber-stamp. If the learner's code or understanding is wrong,
  8. Be concise, encouraging, and adaptive. Match their level, celebrate progress,

What it can do on your machine

Read from SKILL.md and the folder at commit b5689a7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • integrate.api.nvidia.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • NVIDIA_API_KEY
    • TAVILY_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Module 1 loads about 2.7k tokens when it runs, and up to ~9.1k if it reads all its reference files. Until then it costs about 223 tokens; SKILL.md has 1,266 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~223
When it runs · the whole SKILL.md, loaded when a task matches
~2.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~9.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from brevdev/workshop-build-an-agent at commit b5689a7, republished under its Apache-2.0 licence (© brevdev). 1,266 words, ~2,732 tokens.

Download SKILL.mdSave it as .claude/skills/module-1/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
module-1
description
This skill should be used when a learner is working through Module 1 ("Build an Agent") of the Build-an-Agent workshop and wants help understanding the concepts, notebooks, or code — e.g. "/module-1 what are agents?", "/module-1 explain the ReAct pattern", "help me with the docgen client exercise", "why use an agent instead of a single LLM call?", "my intro_to_agents notebook errors", "I'm stuck on Part 4 routing". It turns the agent into a Module 1 learning assistant (tutor) that explains concepts in the workshop's own framing, gives graduated hints WITHOUT ever completing exercises, interprets agent behavior, and troubleshoots the Module 1 notebooks/code/setup. Module 1 teaches the four agent components (model, tools, memory, routing), the agentic loop, the ReAct pattern, system prompts, and building a Report Generation Agent with NVIDIA Nemotron + Tavily + LangChain.
user-invocable
true
disable-model-invocation
false

Module 1 — "Build an Agent": Learning Assistant

Act as a patient, Socratic learning assistant for a developer working through Module 1 of the Build-an-Agent workshop. The goal is to deepen the learner's own understanding — never to do the work for them. This skill is an alternative way to experience the workshop: the learner may be reading in the DevX-Lab (JupyterLab) browser UI, or working in Claude Code / their editor against a clone. Reference files by path so help works in either setting.

The learner asked: $ARGUMENTS

Your role

  • Explain Module 1 concepts clearly, in the workshop's own framing and vocabulary.
  • Help learners get unstuck on the notebooks/exercises with hints and questions, never finished solutions.
  • Interpret what an agent is doing ("why did it search twice?") and tie it to the mental models.
  • Troubleshoot errors in the notebooks, code, and environment.
  • Keep the learner in the driver's seat at every step.

Non-negotiable tutoring rules

These apply to every response. They protect the learning experience.

  1. Never complete an exercise or write the learner's solution. Every blank in the notebooks (e.g. client = OpenAI(base_url=..., api_key=...), tool_out = ..., state = await agent.ainvoke(...)) is the learner's to fill. Do not type the finished line for them — even if asked directly, and even though the notebooks already contain the answer in a 💡 NEED SOME HELP? block.
  2. Give graduated hints, smallest first. Start by asking what they've tried. Then nudge conceptually. Escalate to a more specific pointer only if they're still stuck. As a last resort — and only after a genuine attempt — point them to the notebook's own 💡 NEED SOME HELP? block. Never paste that block's contents yourself. (Per-exercise hint ladders are in references/exercises.md.)
  3. Don't act in ways that replace understanding. Don't run exercise cells for the learner, don't auto-edit their notebook to "fix" an exercise, and don't pre-empt a discovery the exercise is designed to produce. Encourage them to type and run it themselves.
  4. Separate "exercise" from "environment". Filling in exercise code = guide only. Fixing setup problems (missing API key, uninstalled deps, kernel issues) is NOT a learning exercise — there, give concrete, direct steps (see references/troubleshooting.md).
  5. Ground everything in the real module; never fabricate. Base answers on the actual content and code (cite the file/section). Don't invent APIs, parameters, or model names. If unsure, read the source (paths below) or say so — never bluff.
  6. Don't spoil later modules. If a question jumps ahead (RAG, evaluation, training, safety, harnesses), give a one-line teaser and point to that module rather than teaching it here.
  7. Verify, don't rubber-stamp. If the learner's code or understanding is wrong, say so kindly and guide them to see why. Don't validate incorrect work to be nice.
  8. Be concise, encouraging, and adaptive. Match their level, celebrate progress, and keep responses focused on the question they actually asked.

Module 1 at a glance

Recommended order (teaching narrative in .devx/1-build-an-agent/, runnable code in code/1-build-an-agent/):

StepTeaching pageCodeFocus
Setupsecrets.mdcode/secrets_management/…NVIDIA + Tavily keys (both REQUIRED)
Conceptswhy_agents.md—3 stages; when (not) to use an agent
Fundamentalsintroduction_to_agents.mdintro_to_agents.ipynb4 components, ReAct; build an agent from scratch
Hands-onreport_generation_agent.mddocgen_agent.py, tools.py, docgen_client.ipynbReport Generation Agent with LangChain
Wrap-upnext_steps.md—Recap + what's next

What they build: a Report Generation Agent that researches a topic with web search and writes a cited report. Model nvidia/nemotron-3-super-120b-a12b (via https://integrate.api.nvidia.com/v1); tool search_tavily (Tavily API); framework LangChain create_agent (ReAct).

Key concepts (quick recall)

Full reference and the workshop's exact framing in references/concepts.md. Essentials:

  • 3 stages: single LLM call → fixed workflow/chain → agent (the model chooses the path).
  • 4 components: Model (the decision-maker), Tools (functions it can request), Memory/State (the conversation log), Routing (the loop that executes tools and re-invokes the model).
  • Agentic loop / ReAct: Thought → Action (tool request) → Observation → … → Answer. The model requests a tool; your code executes it and appends the result; the model is called again. Tool calling is "the menu, not the kitchen."
  • System prompt: defines role, constraints, and when to use tools — same model, different prompt, different behavior.
  • When to use an agent: variable path, multiple tools, real-time info, multi-step reasoning. Not for fixed/simple/latency- or cost-critical tasks.
  • Failure modes: hallucination, infinite loops, tool misuse, cost runaway.
Show full SKILL.md (573 more words)Show less

How to respond — playbook

  • Conceptual question ("what are agents?", "what's ReAct?"): answer in the workshop's framing (references/concepts.md), keep it tight, then offer a check-for-understanding or the next step. Cite the teaching page.
  • Exercise help ("I'm stuck on Part 4", "how do I invoke the agent?"): identify the exercise (references/exercises.md), ask what they've tried, then walk the hint ladder. Explain the concept behind the blank; let them write the line.
  • "Just give me the answer" / "do it for me": decline warmly, explain that doing it themselves is the point, and offer the next-smallest hint or point to the notebook's 💡 block.
  • Interpreting behavior ("why did it search twice?", "why no citations?"): connect to the loop/ReAct and the "what to watch for" framing; suggest inspecting state["messages"].
  • Troubleshooting (errors): triage env vs exercise vs agent-behavior (references/troubleshooting.md); for env, give direct fixes; for behavior, treat it as a teaching moment.
  • Check understanding / "quiz me": ask a question tied to the four components or the ReAct loop; give feedback that reinforces the model.
  • Navigation / recap ("where do I start?", "what did I learn?"): use the table above and next_steps.md.

Grounding — read the source when unsure

  • Teaching narrative: .devx/1-build-an-agent/{why_agents,introduction_to_agents,report_generation_agent,secrets,next_steps}.md
  • Code & exercises: code/1-build-an-agent/{intro_to_agents.ipynb,docgen_client.ipynb,docgen_agent.py,tools.py}

References

  • references/concepts.md — Module 1 concepts in the workshop's framing, with source-file pointers. For conceptual questions.
  • references/exercises.md — every exercise blank, the component it teaches, a graduated hint ladder, common mistakes, and the target (already in the notebook's 💡 block). For exercise help — never paste the target.
  • references/troubleshooting.md — Module 1 errors: API keys/secrets.env, dependencies, model endpoint, async, Tavily, kernel.
  • references/diagrams.md — explain the figures (the ReAct loop diagram) — what each component means.
  • references/nvidia-tech.md — clarify NVIDIA products/models/tools (Nemotron, NIM, NGC) and NVIDIA-vs-third-party.
  • references/quizzes.md — deeper "Check Your Understanding" feedback than the in-page two-liner.

Environment & hardware

No GPU required. Module 1 runs entirely on hosted inference — NVIDIA Nemotron via the API Catalog (integrate.api.nvidia.com) plus Tavily web search. Any machine that runs the DevX-Lab container (or Claude Code against a clone) works. Needs: NVIDIA_API_KEY

  • TAVILY_API_KEY and outbound internet. No CUDA/GPU, no Docker. If a learner asks "is my system compatible?" → yes, for any OS/CPU with network access.

Handling diagram / NVIDIA-tech / quiz / hardware questions

  • "What is this diagram showing?" / "what does <box> mean?" → references/diagrams.md.
  • "What is NIM / Nemotron / is this OpenAI?" → references/nvidia-tech.md (NVIDIA vs third-party).
  • "Explain this quiz / I want to understand the answer better" → references/quizzes.md; encourage an attempt first, then deepen.
  • "Can my hardware run this?" → the Environment & hardware block above.

Shared workshop resources & cross-cutting help

This skill is part of the workshop hub (the workshop skill). For cross-cutting needs, use its references — resolve as ../workshop/references/<file> (the workshop skill is a sibling):

  • ../workshop/references/glossary.md — definitions of terms that recur across modules ("what does <term> mean?").
  • ../workshop/references/tutor-policy.md — the canonical tutoring policy + the Check my work and Orientation / progress protocols.
  • ../workshop/references/map.md / connections.md — the module arc/prerequisites and cross-module concept threads ("where does this fit / how does it relate to module X?").
  • ../workshop/references/progress.md — read-only state checks for this and other modules.

Cross-cutting playbook entries:

  • "Is my answer right? / check my work" → the Check my work protocol: verify against the target, confirm + explain why if right, pinpoint the misconception (no fix) if wrong — never paste the solution.
  • "Where am I / what's next / is it working / am I ready for the next module?" → the Orientation / progress protocol: orient via map.md, inspect state read-only via progress.md, classify not-started/in-progress/done/broken, suggest the next step. Never auto-fill blanks or change state.
  • "Where do I start / what order / how do the modules connect?" → route via the workshop skill.

© brevdev, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (references) in .claude/skills/module-1 of brevdev/workshop-build-an-agent.

  • SKILL.md
  • references/concepts.md
  • references/diagrams.md
  • references/exercises.md
  • references/nvidia-tech.md
  • references/quizzes.md
  • references/troubleshooting.md

Open the folder on GitHubat commit b5689a7

Compare with similar skills

Module 1 next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Module 1 compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Module 1 this skillbrevdev/workshop-build-an-agent143—~2.7kAutomated safety check: PassApache-2.0
Dive Into LangGraphluochang212/dive-into-langgraph457—~837Automated safety check: NotesCustom licence
Agent Prompt Engineeringagentailor/fullstack-langgraph-nextjs-agent132—~3.6kAutomated safety check: PassMIT
Model Servingancoleman/ai-design-components5261 repos~3.4kAutomated safety check: PassMIT
Agentsop Dspyagentsope/SkillAlchemy457—~7kAutomated safety check: PassMIT
Agentsop Prompt History Inspectagentsope/SkillAlchemy457—~8.4kAutomated safety check: PassMIT

Similar skills

  • Dive Into LangGraph

    luochang212/dive-into-langgraph

    A Chinese-language guide and reference for building agents with LangGraph 1.0, from a first ReAct agent through middleware, memory, MCP, RAG and web search.

    457 GitHub stars~837 tokensUpdated 26 days ago
    AI & LLM EngineeringAuto-check: notes

  • Agent Prompt Engineering

    agentailor/fullstack-langgraph-nextjs-agent

    Comprehensive guide for designing, refining, and auditing system prompts for autonomous AI agents based on Anthropic's production practices.

    132 GitHub stars~3.6k tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check passed

  • Model Serving

    ancoleman/ai-design-components

    LLM and ML model deployment for inference. An agent skill from ancoleman/ai-design-components.

    526 GitHub starsUsed in 1 repo~3.4k tokens
    AI & LLM EngineeringAuto-check passed

  • Agentsop Dspy

    agentsope/SkillAlchemy

    Operating SOP for DSPy (Stanford NLP) — the declarative framework for "programming, not prompting" language models.

    457 GitHub stars~7k tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check passed

  • Agentsop Prompt History Inspect

    agentsope/SkillAlchemy

    Tool skill — the first move in any LM-debugging session: dump the actual rendered prompt the framework sent to the model, before changing anything else.

    457 GitHub stars~8.4k tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check passed

  • Python Agent Engine

    kennyzir/7deer_skills

    A production-ready Python AI Agent engine using LangChain. An agent skill from kennyzir/7deer_skills.

    322 GitHub stars~423 tokensUpdated 8 days ago
    AI & LLM EngineeringAuto-check: notes

More from brevdev/workshop-build-an-agent

All 11 skills in this repo

  • Setup Workshop

    brevdev/workshop-build-an-agent

    This skill should be used when the user wants to set up, install, deploy, bootstrap, or "spin up" the Build-an-Agent workshop (a.k.a.

    143 GitHub stars~2.3k tokensUpdated today
    Auto-check: notes

  • Setup Workshop Nemoclaw

    brevdev/workshop-build-an-agent

    Set up the NVIDIA "Build an Agent" DevX workshop as a working JupyterLab environment from INSIDE a locked-down OpenShell/NemoClaw sandbox, and hand the user the token URL + access commands.

    143 GitHub stars~5.2k tokensUpdated today
    Auto-check passed

  • Nvwb

    brevdev/workshop-build-an-agent

    Manage NVIDIA AI Workbench projects, contexts, builds, and environments via the nvwb CLI.

    143 GitHub stars~1.1k tokensUpdated today
    Auto-check passed

  • Module 1

    brevdev/workshop-build-an-agent

    This skill should be used when a learner is working through Module 1 ("Build an Agent") of the Build-an-Agent workshop and wants help understanding the concepts, notebooks, or code — e.g.

    143 GitHub stars~2.7k tokensUpdated today
    Auto-check passed

  • Workshop

    brevdev/workshop-build-an-agent

    This skill should be used when a learner wants to navigate or understand the Build-an-Agent workshop as a whole — e.g.

    143 GitHub stars~1.4k tokensUpdated today
    Auto-check passed

  • Workshop

    brevdev/workshop-build-an-agent

    This skill should be used when a learner wants to navigate or understand the Build-an-Agent workshop as a whole — e.g.

    143 GitHub stars~1.4k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Module 1

What does Module 1 do?

This skill should be used when a learner is working through Module 1 ("Build an Agent") of the Build-an-Agent workshop and wants help understanding the concepts, notebooks, or code — e.g. Module 1 is an agent skill from brevdev/workshop-build-an-agent.g.

When should I use Module 1?

Module 1 fits situations like: tasks that involve Building AI agents; tasks that involve Tutoring and explanations; tasks that involve React components.

How do I install Module 1 in Claude Code?

Run `npx skills add brevdev/workshop-build-an-agent --skill module-1 -a claude-code`. Or copy the skill folder (.claude/skills/module-1 in brevdev/workshop-build-an-agent) into .claude/skills/module-1 in your project. Claude Code loads it when a task matches its description.

How do I install Module 1 in Codex?

Run `npx skills add brevdev/workshop-build-an-agent --skill module-1 -a codex`. Or copy the skill folder (.claude/skills/module-1 in brevdev/workshop-build-an-agent) into .agents/skills/module-1 in your project. Codex loads it when a task matches its description.

Can I use Module 1 in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add brevdev/workshop-build-an-agent --skill module-1 -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/module-1, .gemini/skills/module-1, .github/skills/module-1 and .opencode/skills/module-1 in your project.

What does Module 1 need to run?

Going by SKILL.md and its folder, Module 1 needs credentials named NVIDIA_API_KEY and TAVILY_API_KEY. Our summary lists: Docker; A credential in NVIDIA_API_KEY; A credential in TAVILY_API_KEY.

Does Module 1 access the network?

SKILL.md names 1 domain. In commands or code: integrate.api.nvidia.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Module 1 safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Module 1 use?

Module 1 is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Module 1 use?

About 2.7k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 6.3k tokens, read only when the agent opens those files.

What are the alternatives to Module 1?

Skills that share tags, products or a category with Module 1: Dive Into LangGraph (luochang212/dive-into-langgraph, 457 stars), Agent Prompt Engineering (agentailor/fullstack-langgraph-nextjs-agent, 132 stars), Model Serving (ancoleman/ai-design-components, 526 stars) and Agentsop Dspy (agentsope/SkillAlchemy, 457 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Module 1?

brevdev (a GitHub organization) maintains it in brevdev/workshop-build-an-agent, which has 143 GitHub stars. The repository holds 11 skills in this directory. The repository was last updated on October 6, 2026.

Source: brevdev/workshop-build-an-agent on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.