Corporate Onsite Syllabus
Effective Agentic Development Workshop
This workshop teaches engineering teams to wield agentic coding assistants—Claude Code, GitHub Copilot, Codex CLI, Cursor, OpenCode, pi, and others—as first-class development tools rather than autocomplete toys. Participants will master the full agentic development lifecycle: context engineering, skills authoring, the agentic dev loop, event-driven backpressure (deterministic tools wired to agent events for imperative self-correction), and production-grade deployment pipelines.
The curriculum is tool-agnostic by design. We teach principles that transfer across any agentic stack while providing hands-on experience with the leading tools of 2026.
Engagement Model 2 × 2-hour online discovery sessions + 2-day onsite intensive
Duration 2 days (16 hours instruction + 4 hours guided lab)
Format Instructor-led, hands-on, cohort-based
Prerequisites Proficiency in Python/TypeScript; Git fluency; basic CI/CD familiarity
Deliverables Agentic dev environment config, BACKPRESSURE.md spec, agentic CI/CD pipeline
Pre-Workshop Discovery Sessions (Online)
Session 1 — Scoping & Stakeholder Alignment
2 hours · 2–3 weeks before workshop
- Audience mapping: Identify participant roles, skill levels, and learning objectives
- Tool audit: Current agentic tools in use (Claude Code, Copilot, Cursor, Codex, etc.) and integration gaps
- Codebase walkthrough: Repository structure, tech stack, existing CI/CD pipeline review
- Pain point identification: Where does agentic development currently break down?
- Customization brief: Identify 2–3 real-world scenarios from your backlog to use as capstone candidates
Deliverable: Customization brief and pre-workshop preparation checklist
Session 2 — Curriculum Customization & Environment Prep
2 hours · 1 week before workshop
- Skill alignment: Identify which modules need depth vs. pace adjustment
- Environment validation: Agent tool installation, MCP server configuration, CI/CD pipeline access
- BACKPRESSURE.md draft: Co-create initial verification contract; identify deterministic tools to wire to agent events
- Materials preview: Review custom playbooks, skills, and repo templates built for your team
- (Optional) Scenario finalization: Lock in capstone project(s)
Deliverable: Finalized curriculum, customized materials, and environment readiness confirmation
Day 1 — The Agentic Dev Environment & The Agentic Dev Loop
Module 1: The Agentic Coding Landscape
90 min
Claude Code, Copilot, Codex, Cursor, OpenCode, pi—and how to choose
- Agentic coding vs. autocomplete: the paradigm shift
- Tool comparison matrix: local vs. cloud, context window, cost, security posture
- Claude Code: terminal-native, bash integration, project-wide reasoning
- GitHub Copilot: IDE-embedded, Copilot Coding Agent (autonomous PRs)
- OpenAI Codex CLI: fast, lightweight, good for scaffolding
- Cursor: IDE-first, composer mode, tab prediction
- OpenCode & pi: open-source alternatives, self-hosting, privacy-first teams
- The tool-selection decision tree: security, cost, team size, codebase scale
Hands-on: Set up Claude Code, Copilot, and Codex CLI side-by-side on the same repo; compare output quality on identical prompts
Module 2: Context Engineering & Memory
120 min
The difference between an agent that hallucinates and one that ships
- The Navigation Paradox: why bigger context windows demand better navigation
- Code graphs for agents: structural dependency mapping (CodeCompass, Serena, LSP)
- LSP integration: Language Server Protocol as an agent's "IDE brain"
.claude/,.cursor/,.github/copilot/configuration directories- AGENTS.md: the project-level behavior contract for coding agents
- Context injection: README-first, ADR-driven, spec-before-code patterns
- Memory architectures: episodic (session), semantic (vector DB), procedural (skills)
- MCP (Model Context Protocol) servers: giving agents executable superpowers
Hands-on: Configure an LSP-aware MCP server; build a custom AGENTS.md for a real codebase; compare agent performance with/without structured context
Module 3: Skills, Tools & The Agentic Dev Loop
120 min
How elite teams pair with agents at velocity
- The Agentic Dev Loop: Prompt → Generate → Verify → Iterate → Ship
- Skills authoring: Markdown instruction files for task-specific expertise
- Databricks-style skills, GitHub Copilot instructions, Claude Code
.claude/skills/
- Databricks-style skills, GitHub Copilot instructions, Claude Code
- MCP server design: exposing your codebase's capabilities to agents
- Code execution MCP (Anthropic pattern: 98.7% context reduction)
- Database query MCP, API testing MCP, deployment MCP
- Tool selection within the loop: when to use grep, when to use LSP, when to use agents
- Prompt engineering for coding: spec-driven development with agents
- The 3-iteration rule: agents self-correct within 1–3 attempts when deterministic tools provide imperative feedback
Hands-on: Author a skill for "Adding a new REST endpoint"; build an MCP server exposing your test suite; run the agentic dev loop end-to-end on a feature request
Module 4: Backpressure I — Structural Verification Gates
90 min
BACKPRESSURE.md defines the contract; deterministic tools wired to agent events enforce it with imperative feedback
- BACKPRESSURE.md: the verification contract that defines what "correct" means
- Syntax rules, type constraints, lint rules, import graph boundaries
- Deterministic tools as imperative feedback: compilers, type checkers, linters, and custom validators wired to agent lifecycle events
- On-write: lint/type-check runs immediately; returns specific directive ("rename variable X", "add null check at line 47")
- On-generate: compilation gates block broken code before it reaches review
- On-test: test runners return failing assertions as imperative corrections
- Why formal gates beat smarter agents: deterministic feedback eliminates guesswork
- The agentic backpressure dial: from permissive (explore) to strict (production)
- Self-correction without human intervention: 1–3 iteration tuning
- Code graphs as backpressure: detecting circular dependencies, dead code, API drift
Hands-on: Write a BACKPRESSURE.md contract; wire deterministic tools (linter, type checker, custom validator) to agent events; measure iteration count to first passing build
Day 2 — Verification, Validation & Production
Module 5: Backpressure II — Testing at Every Layer
120 min
Unit, integration, E2E, visual, and agentic regression testing
- The Agentic Testing Pyramid:
- Unit tests: deterministic checks of prompts, parsers, tool wrappers, serialization
- Integration tests: agent loop validation (perception → reasoning → action)
- E2E tests: multi-agent workflow validation, screenshot comparison
- Agentic test generation: agents that write tests for their own output
- Coverage-gap analysis: "analyze test coverage and find gaps"
- Property-based testing: invariants the agent must maintain
- Playwright for agentic E2E: visual regression, screenshot validation
- Playwright Test Agents: planner, generator, healer
- MCP-driven visual testing: automated screenshot comparison
- Data validation & testing: schema enforcement, drift detection, snapshot testing
- Regression suites for agent-generated code: ensuring past fixes stay fixed
Hands-on: Configure an agent to generate unit tests from a spec; build a Playwright E2E suite with screenshot validation; create a regression pipeline that fails the build on visual drift
Module 6: Agentic Code Review & PR Automation
90 min
Evidence-first review: tests, context packs, and verification loops
- Evidence-first AI code review: tests as the primary review artifact
- Agentic PR review: automated review comments, security scanning, style enforcement
- GitHub Agentic Workflows: coding agents in GitHub Actions
- Triage, documentation, code quality, CI failure analysis
- GitHub Copilot Coding Agent: assign an issue, get a PR
- Autonomous analysis → changes → tests → PR
- PR description generation: context packs for human reviewers
- Reviewer confidence scoring: test coverage + backpressure pass rate + diff size
- Agentic review of agentic code: meta-review patterns
Hands-on: Configure a GitHub Agentic Workflow for PR review; set up Copilot Coding Agent on a sample issue; build a review confidence dashboard
Module 7: DevSecOps, Staging & Blue/Green Deployment
120 min
Agentic code meets production discipline
- CI/CD for agentic development: treating agent output as a build artifact
- Agent version pinning: model versions, prompt versions, skill versions
- Deterministic reproduction: prompt + context + skill hash = reproducible output
- Security gates in the pipeline: secret scanning, dependency vulnerability checks, and SBOM generation for agent-generated code
- Staging environments for agent-generated code
- Smoke testing agent PRs before human review
- Automated staging deployment on agent PR creation
- Blue/green deployment: instant rollback for agent-generated changes
- Canary releases: 5% traffic to agent-built features
- Feature flags: decoupling deployment from release
- Deployment validation gates:
- Health checks, metrics thresholds, error-rate budgets
- Screenshot comparison across environments (staging vs. prod)
- Database migration safety checks
- Security validation: least-privilege deployment credentials, runtime secret injection, and agent-generated config audit trails
- Observability: tracing agent decisions in production
- Model invocation logs, reasoning traces, tool call audit trails
Hands-on: Build a GitHub Actions pipeline for agentic PRs: auto-test → staging deploy → screenshot diff → canary gate → human approval; configure blue/green rollback
Module 8: The Production Agentic Workflow
90 min
Putting it all together: context, skills, backpressure, tests, deployment
- The production agentic workflow blueprint:
- Spec in natural language (issue, ticket, ADR)
- Context injection (AGENTS.md, skills, code graph)
- Agent generation (Claude Code / Copilot / Codex)
- Event-driven backpressure (BACKPRESSURE.md contract + deterministic tools: compile, lint, type-check)
- Test generation & execution (unit, integration, E2E, visual)
- Agentic review (automated PR review, security scan)
- Human review (evidence-first: tests, screenshots, metrics)
- Staging deployment + blue/green validation
- Canary release + monitoring
- Full rollout or automatic rollback
- When to escalate to human: the 3-iteration failure rule
- Team topologies for agentic development: agent operator, backpressure engineer, reviewer
- Cost governance: token budgets, model routing, caching strategies
- Security: sandboxing agent execution, least-privilege MCP access, audit trails
Hands-on: Teams run a full agentic workflow on a curated feature request, from spec to production-ready PR, with all backpressure gates active
Optional Capstone Day (Day 3 — 6 hours)
Add-on package: Core + Capstone Day ($32,500). Teams of 3–4 take a real feature request (from their backlog or a curated scenario) through the complete agentic development workflow, guided by an instructor. Each team must demonstrate:
- Context engineering: AGENTS.md, skills, MCP server configuration
- Agentic generation: Using ≥2 different tools on the same task
- Backpressure compliance: BACKPRESSURE.md contract enforced by deterministic tools wired to agent events
- Test coverage: Unit + integration + E2E (with Playwright screenshots)
- Agentic review: Automated PR analysis with evidence pack
- Deployment plan: Staging → blue/green → canary with rollback triggers
Instructor feedback: Real-time critique using the neurex.dev Agentic Workflow Review framework
Post-Workshop Resources
- Agentic dev starter kit: AGENTS.md template, BACKPRESSURE.md spec, skill authoring guide
- MCP server templates: Code execution, test runner, deployment trigger
- CI/CD blueprints: GitHub Actions for agentic PRs with all gates
- Tool configuration guides: Claude Code, Copilot, Codex, Cursor, OpenCode
- 30-day Slack access: Follow-up troubleshooting and pattern sharing