AI Training Curriculum Builder
Build an onboarding curriculum for agentic coding — week-by-week, role-aware.
The four core themes — setup & safety, prompting & context discipline, agentic workflows, cost awareness & conventions — compress into fewer weeks or deepen across more.
Live curriculum preview
# AI onboarding curriculum — 4 weeks, 14 developers Mixed team: pair seniors with early-career devs in week 3; the review-discipline sessions land best cross-seniority. ## Role mix - Frontend (4 devs): weave in component generation, visual-diff review of AI output, and design-system constraints in prompts - Backend (6 devs): weave in API scaffolding, test-first agent workflows, and schema-aware context files - Platform (2 devs): weave in CI integration, agent permissions/allowlists, and infrastructure-as-code review discipline - Data (2 devs): weave in notebook-to-pipeline refactors, data-privacy rules for prompts, and evaluation of generated SQL ## Week 1 — Setup & safety - Install and authenticate the approved tools; verify everyone can run a first session - Data-classification rules: what may and may never enter a prompt - Secret scanning in pre-commit; incident path when something leaks ## Week 2 — Prompting & context discipline - Writing task briefs the model can act on: constraints, examples, success criteria - Repo context files (CLAUDE.md / AGENTS.md): what belongs and what bloats - When to start a fresh session vs pushing a long thread ## Week 3 — Agentic workflows - Agent-driven changes end to end: plan, execute, review the diff like a hostile reviewer - Tool permissions and allowlists; what agents may and may not touch - Reviewing AI-generated code: ownership rules — the author owns correctness - Role focus: API scaffolding, test-first agent workflows, and schema-aware context files ## Week 4 — Cost awareness & team conventions - Reading your usage: tokens, sessions, cost per task; spotting runaway loops - Model selection: when the cheap tier is the right tier - Codify team conventions: prompt patterns, review norms, budget alerts ## Completion criteria - Every developer has shipped at least one AI-assisted PR through normal review - Team conventions doc exists and was edited by the cohort, not just the lead - Usage dashboard reviewed once as a group — everyone can find their own cost per task Generated with forg.pro/tools/training-curriculum
How it works
Most AI tool rollouts skip training entirely — licenses appear, a Slack message points at documentation, and three months later usage is concentrated in the five developers who would have figured it out anyway. This builder generates the missing artifact: a week-by-week onboarding curriculum for agentic coding, shaped by your team's role mix, seniority profile and the number of weeks you can realistically spend. The markdown preview updates live as you move the sliders; copy it or download it and it becomes the syllabus for your next cohort.
The structure rests on four core themes in a deliberate order. Setup and safety comes first because data-classification rules and secret scanning must exist before habits form. Prompting and context discipline follows — task briefs, repo context files, and knowing when a session has rotted and should be restarted. Week three goes agentic: end-to-end agent-driven changes, tool permissions, and reviewing generated diffs like a hostile reviewer, because the author owns correctness no matter who typed the code. The final theme is cost awareness and team conventions — reading your own usage, choosing cheap models when they suffice, and codifying what the cohort learned into a document the team maintains.
Your inputs reshape rather than decorate the plan. The role sliders weave role-specific practice into the agentic week — visual-diff review for frontend, test-first workflows for backend, allowlists and CI for platform, privacy rules and SQL evaluation for data. The seniority setting changes pacing and pairing structure, and the weeks slider compresses the themes into as little as one intensive week or expands into deepening cycles across eight.
The completion criteria at the end of every generated plan are the part teams most often thank us for: one AI-assisted PR shipped per developer, a conventions doc the cohort actually edited, and one group session reading a usage dashboard. That last criterion needs real per-developer usage data, which is what FORG tracks — and it sets up the natural follow-up: run the adoption metrics calculator a month after the cohort and watch whether sessions per developer moved. Pair this tool with the rollout planner for the org-level sequencing and the usage policy generator for the rules the curriculum teaches.
Frequently asked questions
Why does the curriculum start with safety instead of prompting?
Because the most expensive failure in week one is not a bad prompt — it is customer data or a credential pasted into a third-party service. Setup and safety week establishes the data-classification rules, secret scanning and incident path before anyone builds habits. Teams that teach prompting first create confident users with unsafe defaults, and unwinding a habit costs far more than sequencing the curriculum correctly from the start.
Is four weeks really enough to onboard a team onto agentic coding?
Four weeks is enough to build correct habits; mastery follows in normal work. The curriculum is deliberately practice-heavy — each week assumes developers apply the theme to real backlog items rather than toy exercises. With fewer than four weeks the tool merges themes and trims to essentials, which works for senior teams. With more weeks it adds deepening cycles where the cohort revisits earlier themes against production work.
How does the role mix actually change the generated plan?
Each role contributes a flavor line woven into the agentic-workflows week and the role-mix section: frontend developers get component generation and visual-diff review, backend gets test-first agent workflows and schema-aware context, platform gets CI integration and agent permissions, data gets privacy rules and generated-SQL evaluation. The dominant role also shapes the week-three focus, because training lands when examples come from the work people already do.
What does the seniority setting change?
Pacing and framing. Senior-heavy teams get compressed lecture content and are treated as policy co-authors — they adopt fastest when shaping conventions rather than receiving them. Early-career-heavy teams get added pairing sessions and explicit emphasis that AI output must be understood before it is merged, not merely pass tests. Mixed teams get cross-seniority pairing in the agentic week, where review-discipline habits transfer best from senior to junior.
How do I know the training worked?
The generated plan ends with three completion criteria: every developer has shipped at least one AI-assisted PR through normal review, the team conventions document exists and was edited by the cohort rather than just the lead, and the group has reviewed a usage dashboard together so everyone can find their own cost per task. After the cohort, the adoption metrics calculator gives you the quantitative follow-up: sessions per developer and AI-PR share should rise within a month.
Budgeting AI spend for a team? FORG is $15/dev with hard budget caps and per-seat attribution.
See FORG pricing