Agentic Foundations
Work in a fully agentic environment before building one.
You cannot design agentic systems for other people while you personally still work in a single chat window. This phase rewires how you work first, because every later phase assumes you can delegate the repetitive half of engineering and keep the judgement half.
What you learn
- The four-hats reality: why small teams need one person across SWE, platform, AI, and ML
- Skills, tools, agents, hooks, routines, orchestrators, automation: what each is for and when to reach for it
- Everything-as-code: repos, worktrees, PR flow, agent-written changes you stay accountable for
- Setting up your own agentic workspace: editor agents, CLI agents, guarded hooks, scheduled routines
- Where agents must not be trusted, and how you enforce that on day one
Tools you will actually touch
The assignment pack
You have inherited a repo where three people push directly to main, migrations get edited after they are applied, and nobody can reproduce a review. Convert it into an agentic workspace where the dangerous moves are impossible and the repetitive moves are automated.
- A committed agent configuration: at least one skill, one scoped tool, and one hook
- A hook that provably blocks a dangerous edit (demonstrated by a failing test case)
- One scheduled routine that runs unattended and opens a PR or report
- A written accountability note: what the agent may do alone, and what needs you
Agents are configured but nothing is enforced. The dangerous edit still goes through.
Hook blocks the dangerous class of change, one routine runs unattended, config is committed and reproducible.
Guardrails are tested, the routine has failure handling, and the accountability note shows judgement about where autonomy stops.
The tutorial pack
Build your agentic workspace from zero
- 1Set up a worktree-per-change flow so agent work never disturbs in-flight branches
- 2Write your first skill: encode a repeatable task you do weekly
- 3Define a scoped tool and prove it cannot reach beyond its scope
- 4Add a guard hook that blocks a class of change you have been burned by
- 5Schedule a routine and let it run overnight
Give an agent an unscoped tool and let it do something you did not want, then read the audit trail and add the guard that stops it. You need to feel the failure before the guardrail means anything.
- The dangerous edit is blocked, with the hook output as proof
- The routine completed unattended and produced an artifact
- Time saved on the repeated task, measured before and after
You must be able to answer
AI use is mandatory on every assignment. The integrity mechanism is defend-your-work, so these are the questions that decide whether the work counts.
- “Which of your guardrails would fail first under a determined agent, and why?”
- “What did you deliberately keep manual, and what would have to be true to automate it?”
- “Show the audit trail for one agent-made change. Who is accountable if it broke production?”
Want to be walked through this phase?
The packs are delivered with live teaching, reviewed assignments, and a defence.
Train with me