Claude agent engineering: Master Claude Ecosystem in Six Weeks

Six-week live cohort · 20 seats · 1 November – 6 December 2026 · $400

Over six weeks, you will build a working Claude agent system of your own.

You will start by setting up Claude Code as your engineering environment, turn a repeated workflow into an Agent Skill, rebuild that capability programmatically with the Claude Agent SDK, add a loop that can run, verify, retry, and stop, and finally engineer the context so the system can handle longer, more demanding workflows.

By 6 December, you will have one system that you have built layer by layer and understand from the environment and instructions all the way to agent execution, loops, state, and context management.

Most Claude workflows work well while the task fits inside a few prompts. As the work becomes longer, the failure modes become more structural: the agent repeats work, loses track of state, receives too many tools or irrelevant information, carries stale outputs forward, or fills its context with everything that has happened.

This cohort is about engineering those systems deliberately.

The cohort is limited to 20 participants so there is enough time to review individual implementations during the weekly office hours.

Everything you get

Your enrollment includes:

• Six 3-hour live technical sessions
• Six 1-hour live office hours 
• 24 hours of live instruction and support
• Private Slack group throughout the cohort
• Recordings of every technical session
• Detailed technical documentation for each module
• Complete slide decks
• Source code and implementation examples
• Prompts, commands, and exercises used during the sessions
• The agent system you build progressively throughout the six weeks

At $400, that is $16.67 per hour of live instruction, before the recordings, documentation, code, slides, and reference material are included.

What you will build

The six weeks are not separate introductions to six Claude products.

Each week adds another layer to the same agent system.

Week 1 — Set up Claude Code as an engineering environment

We begin by setting up the environment in which the rest of the system will be built.

You will learn how Claude Code works, how it sees your repository and instructions, how to structure projects for effective agentic development, and how to configure persistent project guidance.

By the end of Week 1: you will have a properly configured Claude Code project that becomes the foundation for the rest of the cohort.

Week 2 — Run longer collaborative work with Claude Cowork

Next, we expand beyond individual coding interactions and design a longer collaborative workflow around the system.

You will learn how to structure multi-step work, maintain continuity across a longer task, define useful handoffs, and decide which parts of a workflow should remain interactive versus repeatable.

The workflow you build here becomes the candidate workflow you will package into a reusable Skill in Week 3.

By the end of Week 2: you will have one complete multi-step Claude workflow that you have run and refined end to end.

Week 3 — Turn a repeated workflow into a Skill that triggers reliably

Once a workflow is useful, repeating the instructions manually becomes unnecessary.

We will turn the workflow from Week 2 into an Agent Skill. You will learn how Skills are structured, how SKILL.md works, how descriptions affect triggering, how progressive disclosure keeps context efficient, and how to package instructions, references, scripts, and supporting resources.

We will build and test the Skill around the workflow you have already created.

By the end of Week 3: you will have a reusable Agent Skill that Claude can discover and apply when the relevant task appears.

Week 4 — Rebuild it as a programmatic agent with the Claude Agent SDK

Now we move from an interactive Claude workflow to an application you control in code.

Using the Claude Agent SDK, we will rebuild the same capability as a programmatic agent. You will work with agent instructions, tools, custom tool integrations, runtime state, sessions, and the agent execution loop.

This is the point where the system moves from something you operate manually inside Claude into something that can become part of an application.

By the end of Week 4: you will have a working programmatic Claude agent that can use tools and execute the workflow from code.

Week 5 — Make it loop: run, verify, retry, stop

A useful agent often needs to continue working without receiving a new human prompt after every action.

We will add a supervisory loop around the agent and cover loop structure, termination conditions, state, verification passes, retries, failure handling, and recovery.

The goal is to make the system capable of deciding whether work is complete, whether another iteration is needed, and when it should stop.

By the end of Week 5: your agent will be able to execute, inspect its result, retry when necessary, and terminate according to explicit conditions.

Week 6 — Engineer the context so it holds under production load

The final layer is context engineering.

As the agent runs longer, context begins to accumulate: instructions, tool definitions, tool outputs, memories, state, intermediate results, and previous decisions.

We will work through the four core context-engineering operations:

Write → Select → Compress → Isolate

You will learn how to move useful state outside the active context, retrieve only what the current step needs, compact growing trajectories, isolate large outputs and state, and use separate context windows where appropriate.

We will apply these techniques directly to the agent built during the previous five weeks.

By the end of Week 6: you will have a complete agent system with an explicit context architecture designed for longer-running production workflows.

The six-week build

By the end of the cohort, the progression will look like this:

Claude Code environment
→ Collaborative workflow
→ Reusable Agent Skill
→ Programmatic Claude agent
→ Supervisory agent loop
→ Production context architecture

You will leave with the implementation, source code, documentation, and a clear understanding of every layer because you built each one yourself.

Weekly schedule

The cohort runs across six consecutive Sundays:

• Week 1: Sunday, 1 November
• Week 2: Sunday, 8 November
• Week 3: Sunday, 15 November
• Week 4: Sunday, 22 November
• Week 5: Sunday, 29 November
• Week 6: Sunday, 6 December

Technical session: 6-9 pm EEST
Office hour: Tuesdays, 7-8 pm EEST

Each week includes a 3-hour technical session and a separate 1-hour office hour. If you cannot attend a technical session live, you will receive the recording and all accompanying material.

Who this is for

This cohort is designed for:

• AI engineers and ML engineers
• Software engineers building with LLMs
• Data scientists moving into AI engineering
• Technical consultants building agentic systems
• Developers already experimenting with Claude Code or AI agents
• Engineers who want to understand how Claude's different agent-building layers fit together

You should be comfortable with Python and basic software development. You do not need previous experience with every Claude product covered in the cohort.

This cohort is not for

This is not an introduction to programming and assumes you can read, modify, and run Python code.

It is also not a course focused only on using Claude through prompts or the chat interface. The later weeks involve programmatic agents, tools, state, loops, and context architecture.

About the Instructor

I'm Youssef Hosni, an AI engineer at Solita and a generative AI researcher at Aalto University.

I also run To Data & Beyond, which reaches more than 27,000 newsletter subscribers and 117,000 followers on LinkedIn.

The modules in this cohort come from technical workshops I have developed and taught individually. My recent Agent Skills workshop sold out all 30 seats, and this cohort brings those individual topics together into one progressive engineering curriculum.