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, an agent that reads your whole system, long-running agents. Plus two optional extensions. For the architectural call your team is sitting on, and a human close on what comes next.

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. 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 an MCP, invoke your first skill, and leave behind a rules file that makes the next session sharper. Then plan mode, treated as an instrument, not a toggle.

I.

Getting going + context

Claude Code wired to your repo, one MCP connected, first skills invoked. 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 MCP wired, a rules file written, your first skills invoked.
Teaching moment
The bug was the vehicle, not the point. You leave with connectors in place, skills in your hands from hour one, a memory that starts learning, 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, pushed back on before approval, executed, then 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

Discipline installed. Memory that compounds.

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 memory across your whole system: repo, services, business rules.

III.

Earn the trust: quality and security

A quality check and a safety boundary, both shipped as reusable skills your whole team can call. The team’s shared kit starts here.

What you build
A quality check and a safety boundary, both as reusable skills. The team’s shared kit starts here. These are the first skills anyone on your team can call.
Teaching moment
Quality and security installed before you need them, so you feel covered when you push an agent off for hours. 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.

An agent that reads your whole system

Memory at repo, across services, and wired to the business rules your code serves.

What you build
Three memory layers: your repo, across services, and the business rules your code serves. An agent that reads all three.
Teaching moment
Memory compounds around the quality checks you shipped in the previous module. Real gates, not prospective ones. Add the business rules your code serves on top, and your agent can weigh in on non-trivial decisions.
Modules 5–6

Hand it off. Walk away. Return with something real.

A few-hour task, drawn from your actual backlog, running on your actual codebase. The agent works while you’re elsewhere. You return, read what happened, sharpen the setup. The schedule is the exercise. The gap between modules is the walk-away.

V.

Long-running tasks: send-off

Build the verifier. Launch a mid-long task. Close the laptop.

What you build
A verifier proven on a small example. Then a two-to-four-hour task launched from your own backlog, running between modules.
Teaching moment
The agent argues with itself, hallucinates a commit hash, drifts off the goal. These failure modes are named before you hit them, so you don’t blame yourself when you do. The discipline is already running; send-off isn’t a leap into the unknown.
VI.

Long-running tasks: return

Return to the scene. Process what happened. Sharpen for next time.

What you build
The diff read. The drift named. The verifier sharpened, then packaged as a reusable skill for the team.
Teaching moment
Evals aren’t infrastructure in the abstract. They’re specific quality checks tuned to specific drift you just watched. You build the check your task demanded, not the one a lecture suggested. The return isn’t a grind, it’s a system.
Modules 7–8 · optional

Two extensions, when the cohort wants more.

The six-module core stands on its own. Add these two when your team has an architectural call in the backlog the whole room should crack together. Or when the cohort wants a human-only close on what comes next.

VII.

When agents meet agents

The whole team’s agents. One real architectural decision.

What you build
A technical decision document, produced live by the cohort’s agents on a real open question your CTO picked. Not authored. Deliberated.
Teaching moment
No single engineer holds the whole picture. The queue handler’s quirks live in one memory, the auth layer’s debt in another, the deploy pipeline’s scars in a third. The deliberation assembles it. The shared kit the cohort built over the core is what makes the deliberation possible.
VIII.

Where is this all going?

Opinion. Fear. Hope. And a considered lecture on what comes next.

What you build
Nothing. Opinion, fear, and hope spoken out loud. Then a considered lecture on where this is going, including what we don’t know.
Teaching moment
Not all answers happen in training. The question is left open on purpose. Engineers carry the question home, not a framework for the answer.
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