DeepDojo.AI
CoursesPricingGuidesBlog

Open courseSkill DevelopmentAI Courses

Claude Code: A Practical Handbook

Combine commands, rules, and tools into a workflow you can verify

Start learning
All chapters
11
Locale
English
Course type
Open course

Start with commands, project memory, and safe recovery from changes. Practice automation, tool integration, and task delegation, then design a workflow with checks and recovery steps. Learn to explain how these capabilities work together.

Best for

  • Developers who use a terminal, editor, and Git and want a structured guide to Claude Code
  • Users who have tried several extensions but struggle to combine and maintain them
  • Engineers who want their teams to share and reuse reliable working methods

Problems solved

  • You keep rewriting prompts for routine operations as tasks change
  • You are unsure which responsibilities belong to commands, rules, or extensions
  • Unattended execution lacks permission limits and failure handling
  • Configuration keeps accumulating, without a clear way to recover when execution fails

Outcomes

  • Design a command or Skill for recurring tasks with clear inputs, outputs, and stop conditions
  • Store lasting project conventions at the appropriate level of memory
  • Explain what checkpoints and Git can each restore
  • Design scripted workflows with structured output, permission limits, and error handling
  • Define which responsibilities belong to tool integrations and which should be delegated as separate tasks
  • Combine capabilities into a workflow with checks, human confirmation, and recovery from failure

Highlights

  • Eleven lessons take you from choosing individual capabilities to designing a complete workflow
  • Practice designing commands, tool integrations, and delegated tasks by drafting small examples
  • Decide whether a plugin serves a real reuse need before adding more features

All chapters

11 chapters

Lesson 1: Start with the Claude Code Way of Working

Judge which Claude Code capability solves a real problem in a given scenario and arrange a hands-on order that builds from foundations to extensions.

Lesson 2: Turn Common Workflows into Slash Commands

Decide which high-frequency tasks deserve a Slash Command and design reusable commands with parameters, context, permissions, and output constraints.

Lesson 3: Manage Project Context with Memory

Place stable project knowledge at the correct Memory level and write concise, low-noise CLAUDE.md rules that do not conflict with other levels.

Lesson 4: Experiment and Recover Safely with Checkpoints

Choose the right Checkpoint and Rewind strategy for a trial-and-error scenario and correctly divide session recovery from Git version control.

Lesson 5: Integrate Claude Code into Scripts and Automation with the CLI

Choose the right CLI mode, permissions, and output format for scripts, pipelines, and CI/CD, and control the risks of unattended execution.

Lesson 6: Package Specialized Capabilities as Skills

Judge whether a piece of work deserves a Skill and design a specialized capability package with clear structure, on-demand loading, explicit permissions, and verifiability.

Lesson 7: Build Automated Controls and Safety Boundaries with Hooks

Choose the right Hook event and handler for an automated control and design a debuggable safety boundary around inputs, outputs, and exit codes.

Lesson 8: Connect External Tools and Data Sources with MCP

Judge whether a need fits MCP and design its transport, authentication, scope, tool loading, and troubleshooting boundaries.

Lesson 9: Decompose Complex Work with Subagents

Break complex work into Subagent tasks with clear responsibilities, minimal permissions, isolated context, and acceptable deliverables.

Lesson 10: Package Team Workflows as Plugins

Decide when a Plugin is needed and design a complete, securely configured, installable, testable, and distributable team workflow package.

Lesson 11: Build a Maintainable Claude Code Work System

Combine Claude Code capabilities for a real project into a work system with clear entries, separated responsibilities, controlled permissions, recoverable failures, and team maintainability.