AI for Programmers: 5-Day Training Course

Daily schedule: 9AM - 1PM 3 sessions/day: 20min lecture + 1 hour exercise

Monday

Day 1

Foundations

Tuesday

Day 2

Frameworks & Constraints

Wednesday

Day 3

Workflow Integration

Thursday

Day 4

Patterns

Friday

Day 5

Applied Practice

9:00
—
10:20

Lesson 1

Foundations & Setup

Lesson 4

Working Within the Framework

Lesson 7

Code Review & Documentation

Lesson 10

AI-Assisted Refactoring

Modernizing legacy patterns

Lesson 13

When AI Fails + Security

Limits, verification & privacy

10:30
—
11:50

Lesson 2

Code Explanation & Learning

Lesson 5

Overconstraining the AI

When it helps, when it hurts

Lesson 8

LLMs in Your CI Pipeline

Lesson 11

API Integration & Pipelines

Scripting & chaining prompts

Lesson 14

Team Adoption Strategies

11:50
—
1:00

Lesson 3

Context Engineering

Getting consistent, quality output

Lesson 6

Generating Readable Code

Lesson 9

Prompt Libraries & Templates

Reusable patterns for teams

Lesson 12

Cross-Language & "Not My Stack"

Lesson 15

Internal Tool Sprint

Prototype a tool that solves a real problem

Day 1 Foundations — Building Trust Through Immediate Value

Lesson 1: Foundations & Setup

Day 1 • 9:00 AM
1hr 20min

20 min Lecture

Why regex, git, and error messages are perfect entry points
The psychology of "low stakes" AI interactions
Tool landscape: ChatGPT vs Claude vs Copilot vs local models
Understanding output variance — AI is probabilistic, not deterministic
Live demo: Same prompt, different outputs across tools

60 min Exercise (includes breaks)

Setup: Everyone creates accounts on 2+ AI tools
Task 1: Generate 5 regex patterns you've struggled with before
Task 2: Use AI to explain a cryptic git reflog situation
Task 3: Feed it your worst error message from the past month
Task 4: Run same prompt on different tools — compare results
Discussion: Share your best output with the group

Starter Prompt

"Write a regex that matches [your specific case]. Explain each part of the pattern and give me 5 test cases that should match and 5 that shouldn't."

Outcome: 4+ concrete wins to use tomorrow + understanding of tool differences

Lesson 2: Code Explanation & Learning

Day 1 • 10:30 AM
1hr 20min

20 min Lecture

The safest AI use case: asking questions costs nothing
"What does this do?" — the zero-risk starting point
Reading unfamiliar languages, frameworks, and patterns
Demo: Explaining a gnarly piece of code in 60 seconds

60 min Exercise (includes breaks)

Task 1: Find code you've never understood — get it explained
Task 2: Paste code in a language you don't know — learn what it does
Task 3: Ask "why was it written this way?" on a confusing pattern
Task 4: Get a line-by-line breakdown of a complex function

Starter Prompt

"Explain this code like I'm a developer who's never seen this language/framework before. What does it do, and why might someone write it this way?"

Outcome: Confidence to explore any codebase without fear

Lesson 3: Context Engineering

Day 1 • 11:50 AM
1hr 10min

20 min Lecture

Why prompt quality determines output quality
Core patterns: role, context, task, format, examples
Iteration strategies: refining prompts systematically
The "prompt library" concept

50 min Exercise (includes breaks)

Task 1: Transform a vague prompt into a precise one
Task 2: Use few-shot examples to control output format
Task 3: Create a reusable prompt template
Group work: Build a shared prompt library for common tasks

Template Pattern

"You are a [role]. Given [context], your task is to [specific action]. Output should be [format]. Here's an example: [example]."

Outcome: Personal prompt library with 10+ reusable templates

Day 2 Frameworks & Constraints — When Structure Helps (and Hurts)

Lesson 4: Working Within the Framework

Day 2 • 9:00 AM
1hr 20min

20 min Lecture

Why frameworks are AI's comfort zone
Game engines (Godot, Unity, Unreal) as structured environments
How AI leverages patterns, conventions, and documentation
Demo: Building a game mechanic in Godot with AI

60 min Exercise (includes breaks)

Task 1: Generate a player controller script in Godot/Unity
Task 2: Ask AI to implement a game mechanic (inventory, combat, etc.)
Task 3: Debug framework-specific errors with AI assistance
Task 4: Compare output quality when you specify the framework vs. generic request

Framework-Aware Prompt

"In Godot 4 using GDScript, create a 2D player controller with: WASD movement, jump with coyote time, and animation state machine. Use CharacterBody2D."

Outcome: Understanding that framework context dramatically improves AI output

Lesson 5: Overconstraining the AI — Overconstraining the AI

Day 2 • 10:30 AM
1hr 20min

20 min Lecture

The constraint spectrum: too little vs. too much guidance
Case study: React/Vue website vs. vanilla HTML/CSS/JS
When frameworks help AI (patterns, conventions, examples)
When frameworks hurt AI (outdated training, niche APIs, version conflicts)

60 min Exercise (includes breaks)

Task 1: Build the same component in React AND vanilla JS — compare results
Task 2: Intentionally overconstrain: specify framework + version + obscure library
Task 3: Intentionally underconstrain: "build me a website" with no guidance
Discussion: When did constraints help? When did they create problems?

Experiment Prompts

Overconstrained: "Using React 18.3 with Zustand 4.5, React Query 5, and Radix UI, build a..."

Underconstrained: "Build me a todo app"

Balanced: "Build a todo app in React with state management. I'm flexible on libraries."

Outcome: Intuition for when to specify frameworks vs. let AI choose

Lesson 6: Generating Readable Code

Day 2 • 11:50 AM
1hr 10min

20 min Lecture

The "trust but verify" mindset — you MUST read the code
Why type annotations matter for AI-generated code
Testing as a verification mechanism
Demo: CLI tool with full type hints, tests, and documentation

50 min Exercise (includes breaks)

Project: Build a CLI tool from scratch with AI
Requirements: argparse/click, type annotations, pytest tests, docstrings
Task 1: Generate the initial structure
Task 2: Read every line — find at least 2 things you'd change
Task 3: Run the tests — do they actually test the right things?
Task 4: Refactor one function based on your review

Project Prompt

"Create a CLI tool that [your choice: converts files, fetches data, generates reports, etc.]. Include: click for CLI, full type annotations, pytest tests with >80% coverage, and Google-style docstrings. Structure as a proper package with pyproject.toml."

Outcome: Habit of examining AI code critically + a working CLI tool to take home

Day 3 Workflow Integration — Making AI Invisible

Lesson 7: Code Review & Documentation

Day 3 • 9:00 AM
1hr 20min

20 min Lecture

Pre-PR self-review: catching issues before teammates do
Security vulnerability patterns AI can spot
Documentation debt: the silent productivity killer
Demo: Review + document a module in 10 minutes

60 min Exercise (includes breaks)

Task 1: Review your own recent PR with AI
Task 2: Scan code for security issues
Task 3: Generate README for an existing project
Task 4: Add docstrings to undocumented functions

Outcome: Pre-PR checklist that catches 90% of review comments

Lesson 8: LLMs in Your CI Pipeline

Day 3 • 10:30 AM
1hr 20min

20 min Lecture

Why automated code review matters: catching issues before humans review
Architecture: GitHub Actions, GitLab CI, or webhooks + LLM APIs
What LLMs can catch: security issues, style violations, logic errors, missing tests
Demo: A GitHub Action that reviews PRs with Claude/GPT

60 min Exercise (includes breaks)

Task 1: Set up a GitHub Action that calls an LLM API on PR diffs
Task 2: Craft a system prompt optimized for code review (security, style, bugs)
Task 3: Handle context limits: chunking large PRs, summarizing files
Task 4: Post review comments back to the PR automatically

CI Review Prompt Template

"You are a senior code reviewer. Analyze this diff for: 1) Security vulnerabilities, 2) Logic errors, 3) Performance issues, 4) Missing error handling. Be specific with line numbers. Only flag real issues—no nitpicks."

Outcome: A working CI pipeline that reviews every PR with AI before human review

Lesson 9: Prompt Libraries & Templates

Day 3 • 11:50 AM
1hr 10min

20 min Lecture

Why reusable prompts beat one-off queries
Anatomy of a prompt template: variables, constraints, examples
Organizing prompts by task type (review, generate, refactor, explain)
Demo: Building a team prompt library from scratch

50 min Exercise (includes breaks)

Task 1: Convert 3 ad-hoc prompts you've used into reusable templates
Task 2: Create a prompt template for your most common task
Task 3: Build a "starter kit" of 5 templates for your team
Share: Exchange templates with another participant

Outcome: A personal prompt library you can share with your team

Day 4 Patterns — Power User Techniques

Lesson 10: AI-Assisted Refactoring

Day 4 • 9:00 AM
1hr 20min

20 min Lecture

Refactoring patterns AI handles well
Modernizing legacy code safely
Extracting functions, classes, modules
Demo: Refactor a 500-line function

60 min Exercise (includes breaks)

Task 1: Convert callback hell to async/await
Task 2: Extract a god class into smaller components
Task 3: Modernize old API usage patterns
Task 4: Add types to untyped JavaScript

Outcome: Refactoring playbook for common legacy patterns

Lesson 11: API Integration & Pipelines

Day 4 • 10:30 AM
1hr 10min

20 min Lecture

Using AI APIs programmatically (OpenAI, Anthropic, etc.)
Chaining prompts for complex tasks
Building AI-powered scripts and tools
Demo: Build a custom AI-powered CLI tool

50 min Exercise (includes breaks)

Task 1: Write a script that calls an AI API
Task 2: Build a git hook that uses AI
Task 3: Chain 3+ prompts to solve a complex problem
Challenge: Create a self-improving prompt chain

Outcome: A custom AI-powered tool you'll actually use

Lesson 12: Cross-Language & "Not My Stack"

Day 4 • 11:20 AM
1hr 20min

20 min Lecture

When and why to translate code between languages
Preserving idioms vs. literal translation
Frontend for backend devs, backend for frontend devs
Demo: Python → Rust with proper error handling

60 min Exercise (includes breaks)

Task 1: Port a script to a new language
Task 2: Build something in your weak area
Task 3: Fix a CSS layout (backend devs) / write SQL (frontend devs)
Pair work: Each person tackles the other's specialty

Outcome: Reduced fear of "not my area" tasks

Day 5 Applied Practice — Making It Stick

Lesson 13: When AI Fails + Security

Day 5 • 9:00 AM
1hr 20min

20 min Lecture

Recognizing AI limitations and hallucinations
Tasks AI consistently struggles with
What goes to the AI (and what stays local)
Company policies, compliance, and sanitization

60 min Exercise (includes breaks)

Task 1: Intentionally break AI with hard problems
Task 2: Spot hallucinations in generated code
Task 3: Audit what you've shared with AI this week
Group work: Draft team AI usage guidelines

Outcome: Healthy skepticism + clear policy for safe AI usage

Lesson 14: Team Adoption Strategies

Day 5 • 10:30 AM
1hr 20min

20 min Lecture

Rolling out AI to skeptical teammates
Measuring productivity impact
Handling resistance and concerns
Building an AI champions program

60 min Exercise (includes breaks)

Task 1: Create a 5-minute demo for skeptical colleagues
Task 2: Draft a team adoption proposal
Task 3: Design metrics to track AI impact
Role-play: Practice handling objections

Outcome: Adoption toolkit to bring back to your team

Lesson 15: Internal Tool Sprint

Day 5 • 11:50 AM
1hr 10min

10 min Kickoff

Identify a real pain point from your daily work
Scope it to something buildable in 45 minutes
Review: CLI tools, scripts, automation, workflows
Demo: Rapid prototyping with AI assistance

60 min Build + Demo

Sprint: Build a tool that solves your real problem
Examples: Log parser, deployment script, code generator, data transformer
Use everything: Context engineering, templates, API integration
Demo: 2-minute walkthrough of what you built

Outcome: A working tool you'll use Monday morning