Agentic Development
Your engineers are already using AI. This teaches them to use it right.
Most development teams have tried AI tools and walked away with a mixed impression. The autocomplete is useful. The longer tasks loop, hallucinate, or produce code that looks right until it breaks something subtle. The gap is not the model. It is that no one taught the engineers how context actually works, or that an agent with the right tools is not a smarter text box but a system that can act in the world.
This course fixes that. Engineers learn the mental model that makes agents reliable, build the structures that carry intent across sessions, and work through hands-on exercises directing an agent through a real codebase task from specification to passing tests. The concepts land whether you have been writing code since assembly language was a practical choice or graduated last year — because they are about mental models and habits, not syntax.
Six months after this course, teams describe a slow compounding effect. Engineers start by automating small tasks. Each one builds confidence and vocabulary. Migrations that had been languishing for years start clearing. Dependency updates happen as a matter of course. Tech debt that no sprint could justify shrinks steadily in the background — while the team is simultaneously shipping new AI-powered features that save their customers real time. The bottleneck that lifts is the cost-threshold for getting things done. Work that used to cost a week of focused engineering time starts costing an afternoon of directed agent work and careful review.
Schedule
The mental model that explains hallucinations, loops, and degrading output. Engineers learn to read a context window as diagnostic information and develop the habits that keep agents on track.
What changes when an agent can read files, run tests, execute shell commands, and call APIs. Live demonstrations of agents acting in a real codebase rather than generating text into a void.
Hands-on practice diagnosing a polluted context, applying the Fork-Clean protocol, and directing a tool-equipped agent through a defined task.
How to write the documents and reusable skill files that give an agent standing instructions, domain context, and safe guardrails — so every session starts informed instead of cold. Includes the four questions every AGENTS.md must answer and how to audit it for bloat.
Designing agent workflows around the interactive-input constraint. Processes that previously needed constant supervision — migrations, dependency updates, multi-step data pipelines — made available for unattended execution.
The red-green-review loop in practice. Engineers write a failing test, hand the task spec to an agent, review the diff against an acceptance rubric, and handle agent drift when it occurs. Everyone leaves having done this with a real bug fix, not a toy example.
Scout agents, reviewer-agent patterns, three-tier routing, and the four metrics that tell you whether your agents are actually working. A map of what to build next once the fundamentals are in place.
What engineers walk away with
Why agents hallucinate and loop — and the specific habits that prevent it. Engineers learn to read a context window the way a senior engineer reads a stack trace: as diagnostic information, not a mystery. This alone changes how they interact with every AI tool they already use.
The difference between an agent that suggests and an agent that acts. When an agent can read files, run tests, execute shell commands, and call APIs, it stops being autocomplete and starts being a capable colleague you can assign work to and walk away from.
Tasks that seemed off-limits because they required human input at each step. Engineers learn how to design workflows around that constraint so processes that previously needed constant supervision can run to completion unattended.
How to write the documents and reusable skill files that give an agent standing instructions, domain context, and safe guardrails. The difference between an agent that starts cold every session and one that already knows the codebase, the conventions, and what it is not allowed to touch.
The red-green-review loop: write a failing test, hand it to an agent with a task spec, review the diff against an acceptance rubric. Engineers leave having done this with a real bug fix, not a toy example, and with a review checklist they can use the next day.
Scout agents for research, reviewer-agent patterns for quality gates, three-tier routing for complex tasks. An introduction to the coordination patterns that make larger autonomous systems possible and the four metrics that tell you whether they are working.
What past participants say
Wes and James delivered an outstanding introduction to Agentic AI for our development team. The class struck the perfect balance between clear fundamentals, hands-on lab work, and real-world examples tailored to our domain. The thorough handouts were especially helpful, and the concept of giving agents well-defined Skills really stood out as a practical way to make them more effective and focused.
Since the training, we’ve seen strong momentum across the team. Developers are actively experimenting with Agentic AI, sharing ideas, and even encouraging other departments to adopt the approach. Wes’s engaging style helped demystify the topic, particularly for our younger developers who were initially apprehensive.
I highly recommend this class to any organization looking to effectively integrate Agentic AI into their workflow.
Who this is for
Engineering teams
The material was validated with both seasoned engineers who have been writing code since assembly language was a practical choice and recent graduates encountering professional codebases for the first time. The concepts land at both levels because they are about mental models and habits, not syntax.
If your team is already experimenting with AI tools but producing inconsistent results, or if you want to establish shared practices before those experiments go in too many different directions, this is the right intervention.
Academic programs
Agentic development is not in most software engineering curricula yet. Students graduating in the next few years will enter an industry where this is a baseline expectation, and most programs have not caught up. We can bring this course into a semester as a standalone module, a workshop series, or a capstone complement.
The hands-on exercises use a realistic fictional codebase, assessment rubrics are included, and facilitator notes cover the failure modes we saw in the room so instructors are not discovering them for the first time during class.
Format
The standard delivery is a full-day workshop. Lecture, live demonstration, and hands-on exercises alternate throughout the day. Participants work in a provided sandbox codebase and finish with a completed exercise they can show their team.
For teams that prefer spaced learning, the material can be delivered across three half-day sessions with work assigned between them. This format gives engineers time to apply concepts in their actual codebase between sessions and bring real questions back to the room.
We deliver on-site or remotely. All exercises work in both environments. For teams with specific stacks or workflows, we can adjust the codebase and examples before delivery so the material connects directly to work your engineers recognize.
Pricing
Priced per student. Volume discounts available for larger cohorts and for academic programs running the course across multiple sections. Contact us with your headcount and we will put together a number.
Pricing depends on team size, delivery format, and any customization scope. Reach out and we will turn around a proposal quickly.
Class materials
A comprehensive reference handout is provided to every participant. It covers all course topics in full detail and is designed to be useful after the workshop ends — as a reference while working with agents in your own codebase.
⟨/⟩ Agentic Development Handout →We read every message and respond within one business day.