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

1The Ad-Hoc Way (0:45)

2The Workflow Way (2:00)

3How It Works (3:15)

4Why This Matters (4:30)

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-agentYou see the green agent indicator in the terminal — a dedicated worker

3️⃣

It invokes the SVG skillweather-svg-creator creates a consistent card layout

4️⃣

Output: same files, same layout, every timeorchestration-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

⚙

InvocationShows 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 contextRuns independently, returns a result, context is discarded

📚

Preloaded skillsweather-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:

🔗

HooksCustom scripts at lifecycle events — PreToolUse, PostToolUse, Stop, and more

👥

Multi-Agent TeamsCommands that orchestrate multiple specialized agents working in parallel

📋

CLAUDE.md ConfigurationProject memory, path-scoped rules, and keeping instructions under 150 lines

🔧

MCP ServersConnect 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