AA Applied Agentics
Enroll now Log in
Open menu
Outcomes Deliverables How you’ll learn Curriculum FAQ
Production-grade agentic workflows. Vendor-neutral.

Agentic workflows for engineers who ship.

A workflow-first course for mid-to-senior engineers: spec → plan → execute → verify → correct. Tool-agnostic, CI/PR-native. Not a tool tutorial. Not prompt theater.

Enroll now View syllabus

For engineers shipping production code (tests, PRs, CI).

For
  • Mid–senior engineers, tech leads, staff+
  • Real repos: CI, PR review, incidents
  • Already using AI; want consistent leverage
  • Care about correctness, maintainability, auditability
Not for
  • Beginners learning to code
  • "Learn Cursor/Windsurf/Copilot" classes
  • Prompt packs / pre-scripted hacks
  • "AI does my job" expectations
Pattern selection matrix
Decision rules (tool-agnostic)
Classify the work
Risk
low medium high
Ambiguity
clear unclear
Blast radius
local cross-cutting
Evidence
tests CI runtime checks
Default pattern by scenario
  • Ambiguous requirements → Spec-first + clarifier
  • Cross-cutting refactor → Planner/Executor + critic/verifier
  • Large solution space → Best-of-N + evaluator
  • Debug/incident → Minimal context + instrumentation-first
  • Safety/security-sensitive → Explicit permissions + no ambient access
Choose the surface
  • Quick reasoning/tradeoffs → Chat
  • Local code edits/navigation → IDE agent
  • Repeatable verification/scripts → CLI agent
  • High-risk changes → Split roles (planner vs executor vs verifier)

Outcomes

A practical course for working engineers: agentic workflows you can apply in real repos without shipping regressions or architectural drift.

North star
Velocity without regret
Faster diffs, fewer regressions, and code that stays coherent six months later.
Decompose work into agent-addressable units

Spec → plan → execute → verify, with tight scope and explicit acceptance criteria.

Choose the right surface for the job

Chat vs IDE agent vs CLI workflows, selected by task shape, risk, and evidence required.

Patterns + context discipline

Planner/executor, critic/verifier, best-of-N, plus drift control and context budgets.

Guardrails + measurable evaluation

Tests, lint/format, diff review protocols, plus metrics like rework, defect rate, and PR quality.

Designed for real repos
Backend • Full-stack • Tech leads
Built around real constraints: CI, PR review, flaky tests, legacy modules, and accidental scope creep.

What you’ll leave with

Practical knowledge you can apply immediately in real repos.

Work decomposition + spec discipline

Turn ambiguous tickets into bounded specs with acceptance criteria and constraints that agents can actually follow.

Agentic patterns + context control

Planner/executor and critic/verifier loops, best-of-N search, and drift control with explicit context budgets.

Verification-first delivery

Guardrails that prevent silent breakage: tests, lint/format, review protocols, and evidence-driven "done".

You’ll also get copy/paste templates (spec/task brief/checklists) so you can implement the workflows immediately.

How you’ll learn

We teach a disciplined workflow you can run on tickets, PRs, refactors, and bug hunts—with explicit verification built in.

What you’ll practice
Define scope → Set acceptance criteria → Require evidence → Review diffs → Ship
  1. 1
    Plan
    Write acceptance criteria, constraints, and what “done” means.
  2. 2
    Execute
    Produce small diffs. Keep boundaries intact. Avoid “helpful” rewrites.
  3. 3
    Verify
    Run tests, lint/format, and sanity checks. No merge without evidence.
  4. 4
    Correct
    When it fails, tighten the spec and rerun verification until it holds.

What engineers get out of Applied Agentics

Outcome statements—these are the behaviors the course enforces.

“Verifier loops + context discipline make results consistent.”

“Smaller diffs, better PRs, fewer regressions.”

“Tool-agnostic workflows that hold up across repos.”

“No silent changes: evidence or it doesn’t ship.”

“A playbook your team can actually reuse.”

Curriculum

A 6-week cohort baseline focused on workflow systems—not tools, not prompts. Every module ends in an artifact you can reuse.

Featured
Capstone: ship with evidence
Apply the workflow to a real repo. You’ll ship a change with tests + verification artifacts and write a short workflow postmortem.
What you’ll produce
  • Spec + acceptance criteria
  • Plan + task briefs
  • PR checklist + verification evidence
  • Shipped change + postmortem
Modules
A fast path from principles to production habits.
Mental models + failure modes
Use AI as a junior dev, pair, reviewer, and refactor assistant—without letting it steer architecture.
Module 1
Spec + decomposition + acceptance criteria
Turn “build X” into bounded work: constraints, definition of done, risk areas, and a plan an agent can execute.
Module 2
Pattern library
Planner/executor, critic/verifier, best-of-N search, tests-first vs spec-first variants—choose patterns by task shape.
Module 3
Context discipline
Context budgets, drift control, canonical context files, reset-and-rederive protocols.
Module 4
Guardrails + verification
Tests, lint/format stability, diff review protocols, “no silent changes” rules, evidence-driven completion.
Module 5
Capstone
Run the full workflow on a real repo: ship, verify, and document the system.
Module 6
Recommended: Security / secrets / sandboxing — containment is part of correctness.

FAQ

Short answers to the questions serious engineers ask before buying.

Is this an ML course?

No. It’s engineering workflow: how to run AI in real repos with verification, guardrails, and review discipline.

Is this a tool tutorial (Cursor/Windsurf/Copilot)?

No. We’re tool-agnostic. We teach decision-making and workflows that transfer across tools and stacks.

Is this for beginners?

Not for beginners. This is for engineers already shipping production code with tests, PRs, and CI.

Do I need a real repo?

Yes. The course is designed around real constraints: legacy modules, flaky tests, CI friction, and scope creep.

What if my repo is messy or tests are flaky?

That’s normal. We treat it as a constraint: tighten scope, add guardrails, and require evidence before shipping.

What do I actually produce?

A workflow playbook + reusable checklists/templates, plus a capstone change with verification artifacts and a short postmortem.

Ready to enroll?

Enrollment is live. Start a draft in 2 minutes. Submit from your dashboard after signup/login.

Enroll now View syllabus