Pro High Med Low
Current = Low

# Claude Code Workflows - Best Practice

From Vibe Coding to Agentic Engineering

Shayan Rais

Intro — 0:00

# The Problem

You're doing vibe coding — and only using a fraction of what Claude Code can do.

# Vibe Coding vs Agentic Engineering

#### Vibe Coding

Type prompts, get results, repeat.

It works — but Claude is just responding to you.

No structure. No repeatability. No workflow.

You're always in the loop. Claude never runs on its own.

#### Agentic Engineering

Define a workflow once.

Claude runs it for you — every time, the same way.

Commands, Agents, and Skills chain together.

You kick it off and walk away. Claude handles the rest.

#### This Video

Covers the foundation: Commands, Agents, and Skills — and how they chain together into repeatable workflows.

# What We'll Cover

#### Demo Project

We'll use the weather workflow from this repo as our running example throughout the video.

Part 1 — 0:45

# The Ad-Hoc Way

Vibe coding the weather task — it works once, but is it a workflow you can trust?

# The Inconsistency Problem

#### The Prompt

Type into a fresh Claude Code terminal:

> What is the weather in Dubai? Write it to an output file and create an SVG card for it.

#### Run 1 — SVG Result

Blue gradient background

Large serif font, centered layout

Output saved to `weather.svg`

Looks fine... until you run it again.

#### Run 2 — SVG Result

Orange card-style background

Small sans-serif, left-aligned layout

Output saved to `output/card.svg`

Different design. Different file path. Every time.

#### The Vibe Coding Problem

It works once. But it's not repeatable. It's not a workflow you can trust. You had to sit and watch it work — and you'll get a completely different result tomorrow.

Part 2 — 2:00

# The Workflow Way

The same task — but as a repeatable, autonomous workflow.

# /weather-orchestrator

#### The Command

Instead of a freeform prompt, type a slash command:

> /weather-orchestrator

### What Happens on Screen

1️⃣
It asks you: Celsius or Fahrenheit?Structured user interaction — not freeform guessing
2️⃣
It spawns a weather-agent You see the green agent indicator in the terminal — a dedicated worker
3️⃣
It invokes the SVG skill weather-svg-creator creates a consistent card layout
4️⃣
Output: same files, same layout, every time `orchestration-workflow/weather.svg` + `orchestration-workflow/output.md`

#### Run it again tomorrow

Same SVG layout. Same file structure. Same clean result. You can kick this off and walk away — it runs autonomously.

Part 3 — 3:15

# How It Works

Command → Agent → Skill — the three building blocks.

# Command → Agent → Skill

The weather workflow chains three building blocks together:

# The full orchestration flow /weather-orchestrator (Command) → AskUser: C° or F°? → weather-agent (Agent + weather-fetcher skill) → weather-svg-creator (Skill) → Output: weather.svg + output.md

#### Command

The entry point — the conductor. Asks the user a question, calls an agent, then calls a skill.

#### Agent

A specialized worker with one job: fetch the temperature. Has a preloaded skill for API knowledge.

#### Agent Skill (preloaded)

`weather-fetcher` is baked into the agent at startup — domain knowledge about which API to call.

#### Invoked Skill

`weather-svg-creator` is called independently via the Skill tool — creates a consistent SVG card.

# Building Block 1: Commands

#### What Is a Command?

A command is the entry point — like a script. It's a markdown file that tells Claude what steps to follow. Think of it as the conductor.

# .claude/commands/weather-orchestrator.md --- description: Fetch weather and create an SVG card --- # Weather Orchestrator 1. Ask the user: Celsius or Fahrenheit? (AskUserQuestion) 2. Invoke weather-agent to fetch the temperature - Task(subagent_type="weather-agent", ...) 3. Invoke weather-svg-creator skill with the result - Skill("weather-svg-creator", ...) 4. Confirm output files are written

### How to Use

📁
Location`.claude/commands/` — one `.md` file per command
⚙
Invocation Shows up as a `/slash-command` in your terminal

# Building Block 2: Agents

#### What Is an Agent?

An agent is a specialized worker. Our `weather-agent` has one job: fetch the temperature. It has its own tools, model, and permissions — an isolated worker.

# .claude/agents/weather-agent.md --- name: weather-agent description: Fetches weather data using Open-Meteo tools: Bash, WebFetch model: haiku skills: - weather-fetcher --- You are a weather data fetcher. Use the weather-fetcher skill for API details. Return the temperature and conditions only.

### Key Properties

🔧
Isolated context Runs independently, returns a result, context is discarded
📚
Preloaded skills `weather-fetcher` is injected at startup — it already knows the API

# Building Block 3: Skills

#### What Is a Skill?

A skill is a reusable set of instructions. Think of it as a recipe. Skills can be background knowledge or standalone actions.

#### Agent Skill (Preloaded)

`weather-fetcher` is baked into the `weather-agent`.

It's domain knowledge — which API endpoint to call, how to parse the JSON response.

skills: - weather-fetcher

#### Invoked Skill (Standalone)

`weather-svg-creator` is called via the Skill tool.

It creates the SVG card with a consistent template — same layout every time.

Skill("weather-svg-creator", ...)

#### Location

Skills live in `.claude/skills/<name>/SKILL.md`

Part 4 — 4:30

# Why This Matters

The difference between vibe coding and agentic engineering is structure.

# Structure Is the Difference

#### Vibe Coding

You type.

You hope.

You get something.

Inconsistent. You're always in the loop. Doesn't scale.

#### Agentic Engineering

You define a workflow once.

It runs the same way every time.

You kick it off and walk away.

Consistent. Autonomous. Repeatable. Trustworthy.

#### The Building Blocks

Commands, Agents, and Skills are the three building blocks. Once you understand these, you can build any workflow.

# What's Next

This repo has more patterns — we'll cover them in upcoming videos:

🔗
Hooks Custom scripts at lifecycle events — PreToolUse, PostToolUse, Stop, and more
👥
Multi-Agent Teams Commands that orchestrate multiple specialized agents working in parallel
📋
CLAUDE.md Configuration Project memory, path-scoped rules, and keeping instructions under 150 lines
🔧
MCP Servers Connect Claude to databases, browsers, and external APIs

#### Get Started

Link in the description. Star it, clone it, and start building your own workflows.

# Quick Reference

Concept | Location | Purpose
--- | --- | ---
Command | `.claude/commands/` | Entry point, orchestration, `/slash-command`
Agent | `.claude/agents/` | Specialized worker with own tools & model
Skill | `.claude/skills/` | Reusable instructions (preloaded or invoked)

#### Two Skill Patterns

Preloaded — baked into agent via `skills:` frontmatter

Invoked — called via `Skill()` tool at runtime

#### The Chain

`/command` → orchestrates

`agent` + preloaded skill → executes

invoked `skill` → produces output

# Thank You!

Questions?

github.com/shanraisshan/claude-code-best-practice

1 / --
`←` `→` or `Space` to navigate