Agentic Engineering 101 · curriculum

Six modules. From daily user to real expert.

For working software engineers. Hands-on from module one, on your own codebase and your own backlog. Get going with agents, plan mode at depth, quality and security discipline before you need it, then your first long-running agents. You observe, build a loop, and learn how to compound through harness engineering.

Format
Make good stuff; the practice follows. Every module is framed around producing something real on your own work. The learning is the side-product.
Who it’s for
Working software engineers who already use Claude Code or Copilot, and want to stop chatting and start wielding agents at scale.
What you need
A laptop, a Claude Code seat, and a real backlog you can work from. A short setup step before module one gets your tools wired. Prior coding experience assumed; prior agent-building experience not required.
Modules 1–2

Getting going. Plan mode at depth.

Ship real work from module one on your own repo. While you do, you wire a connector and leave behind a rules file that makes the next session sharper. Then plan mode, treated as an instrument, not a toggle. Your own read catches some of it; a second agent walking the decision tree catches the rest.

I.

Getting going + context

Claude Code wired to your repo, one connector in place, a personal rules file born from the session itself. All while you ship a trivial bug through a loop that compounds.

What you build
A real fix for a real bug from your own backlog, shipped through a loop you can run again next Tuesday. One connector wired to close the ticket, a personal rules file written from how the session actually went.
Teaching moment
The bug was the vehicle, not the point. You leave with a connector in place, a rules file that starts learning from how you actually work, and a retro habit you can run on Tuesday. The practice that stays when the tool stack moves on.
II.

Plan mode, done right

Plans that look structured get rubber-stamped. Push back before you approve.

What you build
A non-trivial plan, read twice before approval. Your own pushback catches some of it; a second agent walking the decision tree catches the rest. Then executed, and rated against what actually happened. You leave knowing what a good plan looks like on your own work.
Teaching moment
A plan can look structured. Seven items, clear sections, reasonable-sounding. It still gets rubber-stamped. That’s the failure pattern. The act of answering back is what makes you actually read it. Plan mode is a discipline, not a toggle.
Modules 3–4

Earn the trust. Then run the first experiment.

Quality and security installed before you send an agent off for hours. The kind a staff engineer and a CISO can sign off on. Then the first long-running task, scoped from your own backlog and sent off to run while you step away.

III.

Earn the trust: quality and security

Curated security skills do the breadth; a quality skill you author yourself does the part only you can. Your kit starts here, with a path to the team’s.

What you build
A security pass on a feature you’re shipping this week, the access surface mapped and one hardening decision written down. Plus a test-strategy skill you author in conversation, tuned to how your code actually tests. Shipped to your personal kit first, with a clear path to the team’s.
Teaching moment
Quality and security installed before you need them, so you feel covered when you push an agent off for hours. Frontier practitioner moves come curated; you author what only you know, your own system. A staff engineer and a CISO can sign off on the practice before you’ve tried anything big. Installing the discipline early beats retrofitting it after.
IV.

Run the first experiment

Scope a real task, fill the worst gaps, send it off to run on your setup exactly as it stands.

What you build
Your first long-running agent run. You scope a real task from your backlog, walk everything you’ve built so far against it, fill the worst gaps, and send it off to run on its own while you step away.
Teaching moment
The first run is deliberately raw. You’re not shipping a finished result; you’re watching what the agent does with your setup as it stands, so you can name exactly what’s missing. That gap is the whole point. It’s what you build against next module.
Modules 5–6

Learn from the run. Build the loop that compounds.

You read what came back, find what drifted, and re-run the same task equipped to hold its course. Then you turn two runs into a loop. Route each gap to its home, and bank the lesson in a skill the next run inherits. The gap between modules is the walk-away.

V.

Inspect the experiment, re-run it with guardrails in place

Inspect what drifted. Build the check that catches it. Re-run the experiment.

What you build
A read of the first run through three failure lenses: goal drift, context rot, and output that looks right but isn’t. The check that would have caught the worst one. A reference and a plan the agent steers by. Then the same task, re-run with those guardrails in place.
Teaching moment
The contrast is the lesson. Watching the same task run raw, then equipped, lands what no lecture on long-running agents can. You just saw it drift, and you just saw what holds it on course. The failure modes get names before you hit them, so you don’t blame yourself when you do.
VI.

Spot gaps, build the loop

Two runs expose the gaps. Wire the loop that catches them. Harness engineering, on your own work.

What you build
The two runs read side by side. Each gap routed to where it belongs, whether memory, a sharper verifier, or a new skill. Evals mapped across verifier, judge, and gate. A reusable skill that hands the lesson to the next session, so your practice compounds.
Teaching moment
The loop is the deliverable, and building it is harness engineering: the verifiers, gates, and evals that keep a long run honest. A rule you wrote last week won’t fire every run; agents drift even when nothing on the surface changed. You don’t stop the drift, you catch it and encode what you learned, so your practice compounds every time you run it.
Track record

Built on what already worked.

The version of this curriculum that came before Agentic Engineering 101 ran inside a cybersecurity company. The materials there stay with that company. This is a clean rebuild, written from the experience.

More than a hundred engineers trained

The predecessor ran with more than a hundred working engineers inside a cybersecurity company across multiple cohorts.

Scaled internally

Other trainers ran it on their own teams. The shape held without the original trainer in the room.

IV. How we teach

Six rules the curriculum obeys.

Make good stuff; the practice follows

Compounding is the side-product of smart process. Every module is framed around producing something real. The habit forms as a consequence, not a separate goal.

Your codebase, not toy data

Your backlog, your services, your team’s real work. Nothing in the training runs on sample_repo.

We curate the best

We don’t invent the moves. We curate them from the best practitioners shipping today and slot each one into the module where it resolves a real blocker.

Habit for you and your agents

Your practice compounds. Your agents’ memory compounds. Both emerge from doing the work well, not from dedicated practice slots.

Failure modes named, not hidden

The agent argues with itself. The agent drifts off the goal. The output looks right but isn’t. The failure modes are named before they surface, so you recognise them as the tool’s limit, not your own.

The team’s kit is the deliverable

Quality checks, safety boundaries, evals, agents. Built once in the cohort, called by the whole team after.

Ready when you are

Bring a backlog. Leave with an agent that knows your system.

Tell us the team and the rough timing. A 30-minute scoping call is enough. We bring the shape of the engagement and confirm the price.

Start a conversation → See pricing →

Helsinki · Remote & on-site · Finnish & English