Core-12 (default)
F1–F8, one of F9/F10, F11, plus a few advanced sessions chosen at intake (most often A1 and A6).
// corporate ai training
We train software teams to work with AI agents the way engineers work with any other production system: with written requirements, verification, and measurable results — in the same environment where they do their real job.
Vendor-neutral by design — we train your workflow, not just a tool, so you can switch tools whenever you like. Our preferred tool is Claude Code, but the program can run on Codex, Cursor, Copilot, OpenCode, or any other popular tool.
programs assembled around your real needs
every practical assignment based on real-world scenarios
a catalog of dozens of proven topics
groups from a few people to hundreds
support chat, session recordings, detailed self-study materials
Workshops run on your stack and your artifacts; practical assignments ship as pull (merge) requests; results live in an auditable journal with certificates verifiable online.
// the verified training method
Participants train on tasks as close to their real work as possible, in the environment they already use. What gets credited as a training result is real, completed work that meets the quality bar. Every program below runs on the same method.
The curriculum is tuned to your team's tools and needs, varied experience levels and real problem areas; you receive a participant portrait before we start.
2-hour sessions, online or on-site, split roughly 50/50 between theory and practice.
Reviewable, diffable, timestamped. Different difficulty levels make it possible to train people with no coding experience at all, or to upskill senior-level engineers.
The rubric is attached to every assignment when it is handed out; an AI reviewer grades against it; the trainer also reviews the AI's assessments, edge cases and regrade appeals, and personally reviews every final project. Late work is penalized under a published rule, which keeps participants submitting on time.
Every submission and grade is tracked throughout the course. Leadership sees cohort aggregates by default; full per-person detail is enabled at your discretion.
Computed from practical performance, not just handed out; each one can be verified online by number and QR code. A management tool: per-person capability evidence, not just attendance.
After every workshop you get a written review: what was submitted, what passed, and what to fix before the next session.
Slides, session recordings, step-by-step guides, and more.
Start smallThe lowest-risk entry is a pilot: intake survey, one 2-hour workshop, and the group's results. You see the method and your team's baseline before deciding to train the whole staff.
// the programs
The programs are flexible: the topics below form a catalog, and every cohort is assembled from it at intake to match your needs and your specialists' maturity level.
The plans below are examples of formats we have run; the same program can be a short intensive or an extended multi-month course — the plan is settled before the start, and the duration scales with it.
AI agents help support the group and grade the practical work, and that scales well: the same program runs for a team of ten just as well as for dozens or hundreds of participants at once, with every submission still individually assessed and every participant receiving personal feedback.
PricingPer cohort: a base rate per session plus a per-participant fee for verification (grading, journal, credentials). Exact rates are quoted after the intake survey.
// program 1 — the deepest track
AI agents in everyday development work.
After this programYour team ships agent-assisted changes through a verified workflow: written intent, curated context, review tiered by risk.
The recommended pace is one workshop per week, which keeps the balance between intensity and progress. The cadence can be changed, project competitions added, and so on.
Certificates: multi-level at the client's request (with distinction, standard, theory-only). All computed from the journal and verifiable by QR code.
F1–F8, one of F9/F10, F11, plus a few advanced sessions chosen at intake (most often A1 and A6).
A1–A12, for teams that pass a placement diagnostic (fundamental-level homework at L2 difficulty) or have completed Core-12.
F11 + A1 + A2 territory: legacy archaeology, safe changes, judging generated code, PR review and team rules, MCP workflows.
Training plus guided consulting on your real system — your developers drive, the trainer guides and helps with the tricky parts.
The curriculum taught through a real migration project as part of the team's AI transformation (e.g. no-code workflows rebuilt as code by agents).
Goal: every developer delegates routine work to an agent safely — with written intent, curated context, and verification of every result. Each session has an observable objective, and the homework criteria are derived from it. Materials are updated before every session to reflect new tools and approaches.
Where agentic development actually stands: the evidence, why some AI projects take off and others fail, what changes in the developer's role.
Reliable prompting; what may and may not enter a tool; secrets hygiene; prompt-injection defenses; working with synthetic stand-ins.
Managing what the agent sees: repository context, selective attachment, controlling context degradation, reliable first-pass results.
The landscape of modern tools and how they compare across different criteria.
AGENTS.md as the single source of truth, rules files, custom slash commands: the agent follows your team's conventions by default.
Packaging repeatable workflows into reusable, shareable skills — a key element of team expertise.
Connecting ready-made MCPs and building your own for access to external resources (task tracker, documentation, databases, internal APIs), plus permission management.
Goals, constraints, definition of done: specs an agent can act on and a reviewer can grade against. One framework in depth (usually OpenSpec), others compared (Spec Kit, BMAD).
Everyday agentic workflows on the frontend: scaffolding components, refactoring, styling and design systems, design-to-code (from mockup to working component), UI tests that ride along with every change.
Everyday agentic workflows on the backend: APIs, data layers, migrations, debugging, integration tests that ride along with every change.
Reading AI diffs like a senior reviewer; review tiered by blast radius; PR review and team rules, review automation.
README, ADRs and onboarding guides generated and maintained by agents alongside the code, kept honest by the same review pipeline as the code itself. Structuring and maintaining documentation optimized for AI agents.
Goal: the team stops hand-prompting and starts engineering the system that produces code — orchestrated, verified, and improving itself.
Code archaeology, safe changes in systems nobody fully understands, compact context indexes.
Comprehension debt in brownfield work: what to trust, what to re-derive, how to keep understanding when most code is generated.
Skills, hooks, MCP configuration, sub-agents, durable memory: the shared platform that has the whole team working in synergy.
Maker/checker separation: the checker runs on a different model with independent context, escalating to a human when needed; isolated worktrees for agent work; running agents in parallel.
Long-running agents with explicit stop conditions, guarded overnight loops, evidence-gated merges.
The single home of the verification stack: heterogeneous AI reviewers, red/green TDD, mutation testing mechanics, deterministic CI gates that carry the load human reading no longer can.
Eval suites that guard prompts the way tests guard code; every failure becomes a permanent rule, skill, or hook (the ratchet).
Architecture decisions, infrastructure-as-code, CI/CD design with agents in the loop.
The developer's view: generating test suites whose worth is proven against seeded defects (verification mechanics live in A6), plus the economics of test generation.
Token economy, model routing, budgets and quotas, first-pass success rate, TCO modeling and ROI a CFO recognizes.
What a software factory is and who already runs one: factory types, experience from around the world, why factories fail, practices, security and governance, the economics of autonomous code production.
Factory principles shown on a real working factory.
Starting new systems so agents stay effective as they grow: repository layout, tech stack, conventions, documentation and test scaffolds as first-class design inputs.
Agents as product features: agent SDKs, tool design, guardrails, observability, and evals for agents you ship to users.
Retrieval pipelines over your documentation and code: chunking, embeddings, document hygiene, grounded answers with citations, and when RAG is the wrong tool.
Log and telemetry archaeology with agents, hypothesis-driven debugging, and draft postmortems that cut time-to-diagnosis on real incidents.
A working policy for what may enter which tool: data classification, tool approval, audit trails, secure defaults. Also available as a standalone module for security teams.
// program 2
AI agents in QA work.
After this programHow AI agents help your QA team.
A working mental model of agents, practical prompting.
Acceptance criteria turned into checklists, test cases and traceability — generated, then verified.
The connected, governed agent: tracker, test management and knowledge base over MCP with safe permissions; the team library of rules and skills.
Testing against written intent, not folklore: the spec as the artifact QA holds everyone to.
System and integration maps built by the agent — understanding what talks to what without reading the code.
AI-assisted test design and review before any automation; the agent as an exploratory-testing partner; generating test data.
Tests written from plain-language scenarios (Playwright as the reference stack; the method transfers to your framework), plus page-object generation for existing apps. Validation: the pipeline breaks the app, and your suite must notice.
API-level testing, regression tests.
A three-step diagnosis discipline that ends with a draft fix as a pull (merge) request: QA proposes, developers decide. Includes bug reports an agent can act on, with reproduction and context.
Final project
You receive a prepared application with seeded defects (logic / boundary / integration classes, injected by the grading pipeline, categories undisclosed). Deliver a test suite and diagnosis packages that catch at least 60% of the seeded defects. Building your own small product with AI is offered as the L3 stretch option.
// program 3
AI agents in business-analysis work.
After this programYour analysts produce requirements that agents, testers and developers can act on directly: grounded in the real system, with quality scored against a reviewer rubric.
A working mental model of agents, practical prompting and cost.
From raw conversations, documents and meeting recordings to acceptance criteria that agents, testers and developers can all act on, including process documentation drafted straight from recordings.
The tracker and the knowledge base as the agent's working memory over MCP. The analyst team library: story templates, review rubrics, generation guardrails, and stakeholder-communication drafts grounded in the tracker rather than written from memory.
The spec as the artifact everything downstream hangs on, written so an agent can act on it.
Writing implementation-aware requirements.
From problem statement to epics and stories with an agent: faster drafts, human judgment on scope. The session ends with an epic/story generator packaged as a reusable team skill.
Clickable prototypes generated from stories and validated with stakeholders before a line of production code is written, plus UAT scenario packs generated from the same stories.
Data questions answered by scripts the agent writes and the analyst validates. A full session, not an afterthought.
The agent reviews specs against a rubric before developers ever see them, and requirements quality becomes a number.
Final project
A complete package from problem statement to stories, prototype, UAT scenarios and tracker tasks. The test: the trainer injects two requirement changes near the end; all downstream artifacts must be updated with zero contradictions found by the AI reviewer.
// program 4
QA and BA trained as one cohort.
After this programOne shared language and one team library across QA and BA, and the requirements-to-tests handoff practiced on shared artifacts in the capstone.
Principles of AI agents: delegation, context and cost
allRequirements analysis and refinement: from acceptance criteria to test artifacts
allA unified ecosystem: agent, tracker and knowledge base via MCP
allSpecification as a contract: Spec-Driven Development with OpenSpec
allRules, skills and guardrails. The team library
allTechnical context from code: a map of systems and integrations
allAutomated tests in natural language and their validation
QAAPI tests, regression suites and CI/CD
QADefect diagnosis and a draft fix
QADiscovery and decomposition
BAPrototyping and data analysis through script generation
BAAI as a reviewer: measurable requirements quality
BAThe handoff capstone: QA tests what BA specified, in a joint final review on shared artifacts
allFinal projects
Both role finals (QA: ≥60% of seeded defects caught; BA: the change-injection consistency test), connected in the capstone, plus the shared team library as a cohort deliverable.
// program 5
Strategy sessions for engineering leadership.
After this programA defensible AI delivery strategy: what to automate, what to verify, what it costs, and what policy makes it safe. Grounded in evidence, not vendor decks.
What autonomous software production looks like today: the evidence, who runs factories, why most attempts fail, security and governance.
Factory principles on a working reference factory, holdout verification shown live, separation of duties, and a live factory run with real compute spend.
Token economy, model routing, budgets, first-pass success rate, TCO and ROI: the cost curve and how to invert it.
Why story points and velocity models break when agents compress implementation time; estimating by verification and review cost instead of typing time; token budgets next to person-hours; forecasting from first-pass success rates; and planning around the new bottleneck, review capacity.
What the lifecycle looks like when agents write most of the code: spec-first flow with verification gates; how the developer, QA, BA and architect roles shift; team topology, hiring and seniority in the new pipeline.
Running a team on shared agent infrastructure: team libraries of rules, skills and prompts; ownership and review duty when agents produce most changes; onboarding and knowledge flow. Artifacts that compound in value instead of rotting in a wiki.
AI usage policy, data classification, verification gates, team readiness, and how to sequence the role programs above.
// corporate ai training
Tell us the roles, the stack and the constraint. We survey the team before session one and shape the curriculum to what the data says.