Editor’s note
This session grew from a question many (or all) of us have asked after an agent produces something impressive: Can I trust this enough to use it? Youssef Hosni and Luca Berton answer not with reassurance, but with the practical engineering that allows trust to be earned.
There is a particular moment many of us recognise when working with a coding agent. It produces something impressive, perhaps much faster than we could have written it ourselves—and then we pause.
Did it follow the repository’s conventions? Did it test the right things? What did it overlook? How much of this can we safely trust?
That pause is what this webinar is really about.
Youssef Hosni and Luca Berton show us that the answer is not simply a better model or a longer prompt. It is the engineering we build around the model: the agent harness.
Teach the agent how you work
Youssef begins with skills: reusable procedures that capture how you want recurring work to be done.
His demonstration uses a code-review skill that asks the agent to inspect correctness, consider edge cases, examine the relevant tests and support its findings with evidence. Instead of explaining that process again in every prompt, you teach it once and continue refining it as you learn.
He also draws an important distinction between the different parts of a harness:
A prompt describes the task in front of you.
CLAUDE.mdorAGENTS.mdexplains how the project works.A skill preserves a reusable procedure.
A tool allows the agent to take an action.
A subagent handles a focused piece of work in a separate context.
It is a small shift in thinking, but a meaningful one. You are no longer hoping that the agent interprets one enormous prompt correctly. You are giving its work a structure it can return to.
Give yourself evidence, not reassurance
Luca takes the next step: how do you know the result is actually safe to accept?
His example starts with a subtle bug. Searching for active customers also returns those marked inactive, because the original function relies on substring matching. Claude Code fixes the implementation, but Luca does not stop at a plausible answer.
He adds a hook that automatically runs the unit tests whenever the agent changes a file. He then introduces a read-only reviewer subagent, working in a separate context, to compare the implementation against its acceptance criteria.
Finally, he adds guardrails that prevent the agent from touching protected files, altering its own configuration, or committing and pushing code. The agent can help with the work without quietly inheriting authority it was never meant to have.
Together, the demonstrations create a practical loop:
Provide context → invoke a skill → make the change → run automatic checks → review independently → enforce permissions → let a human decide.
What I appreciated most about this session is that it does not ask us to trust agents more blindly. It shows us how to create the conditions in which trust can be earned.
The aim, as Luca says near the end, is not simply more autonomy. It is autonomy with evidence.
Watch the full webinar to see Youssef and Luca build each layer—and to borrow the parts that could make your own work feel a little less uncertain.
Keep building with Youssef and Luca this weekend
If the webinar leaves you wanting to build these ideas yourself, both speakers are returning for hands-on sessions this weekend:
Saturday, October 17: Agent Skill Engineering with Youssef Hosni
Sunday, October 18: Claude Code Bootcamp Cohort 2 with Luca Berton
You can join either session individually or book them together as a weekend bundle to save a few dollars.
That’s it for this one. We’ll pick up the conversation next week.
Until then, keep building.
Tanya D’cruz
Editor-in-Chief
