Agent Harness Fundamentals: Building Reliable AI Agents with Claude Code

Join Luca Berton and Youssef Hosni for a free Claude Code webinar on agent harnesses, hooks, subagents, automated tests, guardrails, and human review.

Luca Berton · AI Advisor & Architect

Published October 11, 2026 · 4 min read

A coding agent can finish a task. Can you prove that its changes are safe to accept?

That is the question behind Agent Harness Fundamentals, a free live webinar I’m presenting with Youssef Hosni, hosted by Packt Publishing.

Claude Code can explore a repository, make changes, and run commands. But greater autonomy needs an engineering layer around it: clear context, reusable skills, independent checks, tool limits, and a human who makes the final decision.

The goal is not more autonomy. It is autonomy with evidence.

Join the Free Webinar

When: Sunday, October 11, 2026, at 10:00 AM Eastern (14:00 UTC)
Duration: 10:00–11:30 AM Eastern (90-minute event)
Where: Live and virtual
Cost: Free
Speakers: Youssef Hosni and Luca Berton

Register for Agent Harness Fundamentals on Eventbrite →

The session covers skills, tools, guardrails, and control for reliable AI agents with Claude Code. We’ll explore how prompts, CLAUDE.md, Agent Skills, specialized subagents, and deterministic checks fit together rather than adding yet more instructions to a single prompt.

From “It Works on My Prompt” to “Show Me the Evidence”

Fast code is not the same as safe progress.

Without a harness, it is easy to accept a change simply because the model says it is done. With a harness, we can ask better questions:

Did the agent preserve the behavior that already worked?
Did tests actually run after the change?
Did an independent reviewer inspect the implementation?
Were prohibited operations constrained by permissions?
Can a human inspect the diff and decide whether to accept it?

For my 25-minute live demonstration, “Claude Code: Autonomy with Brakes,” I use a small, concrete workflow:

Claude Code implements → a hook runs tests → a subagent reviews → guardrails limit actions → a human accepts or rejects.

Here is what I will demonstrate.

1. Claude Code: One Request, Observable Behavior

We start with a small customer-search function, not a sprawling application architecture.

The task is simple: add a status filter, preserve existing behavior, add tests, and do not commit.

Before the change, the search returns three customers:

$ python3 customer_demo.py a
Ada, Grace, Mina

With the new active filter, the target result is:

$ python3 customer_demo.py a active
Ada, Grace

The point is not that Claude Code can write a filter. It is that we define observable behavior and evidence that the change meets the request.

2. Hooks: Tests Run Because an Event Happened

A reliable process should not depend on the model remembering to run tests.

I’ll show a PostToolUse hook that responds to matching Edit or Write tool events and runs a deterministic check:

python3 -m unittest discover -s tests -q

The flow is straightforward:

Code edit → matching tool event → unit tests → PASS or FAIL feedback.

An important distinction: PostToolUse happens after the edit. If the tests fail, the hook supplies feedback; it does not automatically roll back the file. That makes the test results useful evidence, not a safety mechanism that magically undoes every bad change.

3. Subagents: A Reviewer That Did Not Write the Code

Next, I’ll delegate a narrow review to a separate Claude Code subagent.

The reviewer has fresh context and only read-capable tools: Read, Grep, and Glob. Its job is to inspect the feature request and the resulting code, then report PASS or ISSUES.

Among the questions it checks:

Was the original behavior preserved?
Are the new tests meaningful?
Was the file that should stay untouched actually left alone?

The reviewer inspects the implementation and tests. It does not execute tests or modify code in this demonstration; the hook and the human handle execution and final judgment.

An independent reviewer is useful precisely because it can disagree with the agent that made the changes.

4. Guardrails: Instructions Guide, Permissions Constrain

Putting “never edit data.py” in CLAUDE.md provides guidance. It is not enforcement.

Claude Code tool permission rules provide another layer: they can deny matching direct actions such as edits to a protected file or a git push command. These are useful guardrails, but tool permission rules are not an operating-system sandbox.

That distinction matters when designing reliable agentic workflows. We need to understand what each control actually guarantees instead of treating all controls as interchangeable.

5. The Final Gate Belongs to a Human

At the end, we inspect the diff and run the test suite again:

diff -u .baseline/customer_demo.py customer_demo.py
python3 -m unittest discover -s tests -q

Then comes the decision: accept or reject?

In the demonstration there is no automatic commit and no automatic deployment. The model proposes the change; the human decides whether the evidence is sufficient.

Who Should Attend?

This free session is designed for software developers, AI application engineers, backend and full-stack developers, platform and DevOps engineers, technical leads, and anyone experimenting with coding agents.

You don’t need to be an expert in Agent Skills. Basic programming knowledge and some familiarity with AI tools will help you follow the examples.

Meet the Speakers

Youssef Hosni is an AI/ML engineer, agentic AI researcher, doctoral researcher at Aalto University, and founder of To Data & Beyond.

Luca Berton is a Claude Code Certified Expert Instructor, AI-first developer, author, and educator. My demonstration focuses on what it takes to make agent-driven changes verifiable and controlled.