Claude Code Harness and Mods, Graph Engineering: Advanced CLI Harness Engineering in Practice

Claude Code can be fun in a GUI.

However, Claude Code pays off in CLI harness design.

This course does not introduce Claude Code CLI as merely an AI coding tool. Instead, it covers how to establish Claude Code within real backend and DevOps workflows through the lenses of Context, Permission, Verification, Tool, Subagent, and Debugging Harness. By connecting log analysis, bug fixes, test recovery, CLAUDE.md design, session management, and parallel worktree operations, you will learn how to design a work system that allows Claude to operate safely in real-world projects.

Recommended for those who:

After completing the course,

After taking this course, you will no longer see Claude Code as merely a tool for “entering good prompts.” Instead, you’ll be able to determine what Claude needs to see, how far it can act, how to verify its results, when to use clear/compact/restart if a session becomes contaminated, and how to manage worktrees and parallel sessions.

Specifically, you will be able to structurally codify project rules and prohibitions in CLAUDE.md, organize log, environment variable, and configuration scope issues into a form Claude can solve, and review the changes Claude proposes through a loop of testing, diff inspection, and counterexample verification. In other words, you will elevate Claude Code beyond a GUI-based assistant to a level where it can be integrated into actual backend and DevOps workflows.

From Claude Code that needs to be instructed every time to Claude Code that works according to my rules

“Check the tests, too.”
“Ask me before running that command.”
“Don’t leave sensitive information in the logs.”

The more you use Claude Code in real-world work, the more often you find yourself repeating the same instructions. That’s because deciding which tasks to allow and what to verify before considering a task complete is just as important as writing code quickly.

In this Claude Code Mods section, you will implement these requirements in code. Following the eight lessons, you will gradually build a hands-on project called Harness Guard Kit.

• Deciding Before Execution: Review tool calls and handle forwarding, approval requests, and rejections according to the established rules.

• Managing sensitive information and work records: Redact sensitive information from logs and design records that allow work to be tracked.

• Checking completion criteria: Configure a Completion Gate so that work does not end without performing all necessary validations.

• Observing context and costs: Read context, cache, and cost information, and distinguish between observed and estimated values.

• Testing behavior and sharing it with the team: Evaluate not only normal situations but also rejection and error scenarios, and cover the deployment, update, and rollback flows.

This goes beyond simply using installed features: it is a process of directly designing how Claude Code should behave for your project.

Recommended for developers who want to connect work principles to actual execution flows, developers who spend time repeatedly reviewing AI-generated results, and developers who want to turn their team’s work standards into reusable tools.

The hands-on exercises are conducted in a testing environment, where you’ll also learn how your custom-built Guard works together with Claude Code and your organization’s existing permission policies.

Features of This Course

1. Rather than explaining features, it teaches from a “harness engineering” perspective based on research papers.

This course does not simply list Claude Code’s features like official documentation. Instead, it explains how to design Context, Permission, Verification, Tool, Subagent, and Debugging Harness so that Claude Code can work safely on real-world projects. This makes you less affected by rapidly changing version information while leaving you with principles that can be applied to actual projects.

2. It is based on large codebases and real-world problems

Rather than simply building demo apps, this course covers how to keep Claude from getting lost in large codebases, reduce session contamination, safely manage worktrees and parallel sessions, and connect the GitHub Issue → PR workflow with Claude. It starts with the points where people actually get stuck in real-world work.

You’ll learn the following

Getting Started with Claude Code CLI for Practical Work /

Architecture / Memory / CLAUDE.md / Plan Mode / Skills

In the first section, we clearly lay out the differences between GUI-based Claude and the CLI, starting with the basics. Rather than simply comparing interface differences, we explain why GUI workflows tend to stop at “asking a question and receiving an answer,” while the CLI can connect all the way to actual logs, tests, Git, and deployment preparation. We then use Claude Code architecture to understand why the harness is more important than the model, and explore the role of memory across sessions and CLAUDE.md, as well as the differences between Plan/Thinking Mode and Subagents, and between Skills and Tool use.

Harness configuration files you can copy and use right away

The harness configuration you create directly in the course is provided in full as completed files.
After taking the course, you can copy it into your own project and apply it right away without having to write it all again from scratch.

The provided settings are as follows.

• CLAUDE.md
  Defines the working rules Claude must follow in the project.

• codecraft-harness/SKILL.md
  Transforms a short, ambiguous one-sentence request into a concrete design and implementation plan.

• solid-review/SKILL.md
  Before starting implementation, check whether responsibilities are appropriately separated and whether the design is unnecessarily complex.

• block-sensitive-paths.sh
  .env, SSH keys, project parent directories, and other sensitive files and paths are blocked from access.

• run-tests-after-edit.sh
  Automatically runs the relevant tests every time Claude modifies a file.

• block-stop-without-tests.sh
  Prevents you from reporting a task as complete when tests have not been run or have failed.

• guard.sh
  It blocks even unauthorized external network requests, creating a safe execution environment.

The Hooks included in the course are not just sample code.
They were all run and verified in a real-world environment.

Once the configuration file is registered, tests run automatically every time Claude modifies the code, and when tests are failing, it cannot arbitrarily end by saying, “I’ve completed the task.”

In other words, rather than merely asking Claude to verify its work through prompts, you will learn how to make the system enforce the verification process.

3. Model-Specific Prompt Playbook

Even when using the same harness, the instructions each model follows well and those it tends to overlook differ.

In this course, instead of using the same prompts for every model, we provide five copy-ready prompt blocks outlining which instructions to remove and which to add based on each model’s characteristics.

• Opus 5
  Reduce the verification instructions the model performs on its own to prevent unnecessary duplicate work.

• Opus 4.8
  Make the tool execution conditions more explicit so that the necessary tools are used at exactly the right time.

• Sonnet 5
  This covers how to write, in literal and specific terms, the files that need to be modified and the scope of the changes.

• Haiku 4.5
  It lays out the execution procedure step by step so you can work reliably even with models that do not have an effort option.

• Fable 5
  We provide, for reference, an approach that avoids giving the model excessive instructions and retains only the necessary prescriptions.

Each playbook also includes the following content.

• Parameter combinations that cause a 400 Error when requested

• Default parameters and behavioral differences by model

• A record sheet for comparing results while changing the effort value

• Lab 04 exercise: Run the same prompt on multiple models and compare the results

Rather than simply explaining “which model is better,” you will learn how to find the optimal settings for each model yourself by repeatedly running the same task and recording the results.

Graph Engineering Practice Materials — Lab 05

You will directly compare the approach of processing complex tasks sequentially in one go with the Graph Engineering approach of dividing tasks according to their dependencies.

Interactive Learning Sheet

You can use it by opening the HTML file in a browser, without any separate installation or server startup.

You can play back step by step how the same request is handled differently in the following two approaches.

• Repeating a single flow with loop-based execution

• Graph-based execution that divides a task into multiple nodes and dependencies

When you select each step, you can also view the configuration file that created that action, allowing you to immediately understand the relationship between the execution result and the configuration.

Step-by-Step Learning Guide

We provide a learning guide totaling 645 lines.

Rather than explaining the theory at length from the start, it is organized in the following order.

Check the conclusion → 30-minute practice → core concepts → advanced theory

There are also separate learning paths for non-majors and for learners with development experience.

Even those using Claude Code for the first time through vibe coding can start with hands-on practice, while developers can delve deeper into its internal workings and design principles.

Three demo projects you can run yourself

Rather than simply reading configuration files, you will run claude in an actual project folder and directly observe how Hooks block and validate tasks.

Each project intentionally includes the following issues.

• Type error

• Test failure

• A logic bug that appears normal on the surface

Learners will directly experience the following flow.

Detect the issue → Block the task → Fix the code → Run the tests → Pass validation

Loop-based and graph-based projects use the same code, with only the harness configuration set up differently.

Therefore, you can accurately compare how the results differ due to the way the work is organized, not differences in the code.

Reference documents

Practical documentation is also provided so that you can refer to it when setting up projects or solving problems even after completing the course.

• Environment Setup Guide
  A summary of how to prepare the execution environment, register Hooks, and resolve common errors.

• Distinguishing the Roles of Skills, Hooks, CLAUDE.md, and Tests
  Explains what each component is responsible for and which tool to use for each problem.

• Harness Inspection Checklist
  Verify that nothing is missing from the prompt, design, implementation, tests, and completion criteria.

• Question and test cards
  Provides questions to use when requirements are ambiguous, test design criteria, and verification table templates.

• Model-Specific Playbook Documents
  Parameters, behavioral characteristics, and prompt-writing guidelines for each model are organized in one place.

• Model Evaluation Record
  You can run the same task with multiple models and configurations, then compare and record the results.

These materials are not merely course supplements; they comprise a Claude Code harness operations manual that you can repeatedly use in real-world projects.

The person who created this course

• Silicon Valley Survivor | American Snail 

  Drawing on experience and expertise gained at the forefront of the Global Tech Scene, this course shows non-majors how to overcome technical barriers and become the owners of their businesses.

  • Current) Founder of a Silicon Valley AI coding & local model fine-tuning agent startup

    • Development and operation of Closiro CLI/Mac Desktop (20K+ downloads)

    • Selected for the Google for Startups Program

    • Selected for the Anthropic for Startups Program

  • Former engineer at U.S. Big Tech companies and promising startups

    • Gave up the final stage at Amazon to start a company

    • Silicon Valley AI Fintech Startup Engineer

    • OpenAI / Meta / Apple / Adobe / Amazon Full-Stack Fellowship

    • Domestic search engine portal, fintech development

    • AI startup AR/B2B/SDK development

  • Proven educational expertise

    • Double major in Computer Science and Business Administration at a four-year university in Seoul, with extensive startup experience

    • Produced over 2,100 students in total; 4.5K+ followers on the social media platform Threads / 500+ Substack followers

    • Threads: https://www.threads.com/@rich_l_2024?igshid=NTc4MTIwNjQ2YQ==

    • Substack: https://open.substack.com/pub/1234373801

Do you have any questions?

Notes Before Taking the Course