Updated June 2026

AI-Assisted Development with JavaScript and TypeScript

Class Duration

35 hours of live training delivered over 5 days.

Student Prerequisites

Professional JavaScript or TypeScript development experience
Working knowledge of Git and GitHub (issues, pull requests, branches, reviews)
Comfort with the command line and the Node.js / npm ecosystem
No prior AI tool experience required

Target Audience

Professional JavaScript and TypeScript developers - front end, back end, or full stack - who want a structured, end-to-end path from AI-curious to AI-proficient. Ideal for engineers and teams adopting AI coding tools across the full development lifecycle - writing, refactoring, testing, reviewing, and shipping JS/TS code - who also need to understand the security, licensing, and governance implications of doing so responsibly. This is a tool-agnostic course: each delivery is tailored to the AI tools your organization chooses - Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, or others - and the skills transfer to whichever assistants your team adopts. For the language-agnostic version of this material, see AI-Assisted Software Engineering Fundamentals.

Description

No language ecosystem has more AI-generated code flowing through it than JavaScript and TypeScript, and none has more ways for that code to go subtly wrong, from loose typing to hallucinated npm packages to framework APIs that changed last quarter. This five-day intensive teaches professional JS/TS developers to get the productivity without the mess, starting with how large language models generate code, setting up and configuring whichever tools your organization chooses, and prompting and context engineering techniques that produce strictly-typed, modern TypeScript. Daily practice follows: disciplined inline assistance, chat-driven explain-refactor-generate workflows, grounding assistants in project context with CLAUDE.md / AGENTS.md and rules files, and full agentic workflows where the agent runs the type checker, linter, and test suite. Day four applies AI to quality across the lifecycle: Vitest and Playwright suites, AI-assisted debugging, refactoring at scale, migrating legacy JavaScript to typed TypeScript, and documentation. Day five addresses team-scale adoption: npm supply-chain risks, secret handling, licensing and IP questions, organizational policy, cost management, and rolling AI out with honest productivity measurement. This is a tool-agnostic course: each delivery is tailored to the AI tools your organization chooses (Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, or others).

Learning Outcomes

Explain how LLMs generate code, choose the right frontier model for a given JS/TS task, and set up and configure your chosen AI tools with sound privacy and data controls.
Apply prompting and context engineering techniques that produce strictly-typed, modern TypeScript.
Use inline completions and chat-driven explain, refactor, and generate workflows with discipline: well-scoped context, clean conversation hygiene, and review reflexes.
Ground assistants and agents in project context with CLAUDE.md / AGENTS.md, rules files, MCP servers, and shared team prompt libraries, and use AI to read and understand unfamiliar codebases.
Drive agentic coding sessions with your chosen coding agents, with tsc, ESLint, and the test suite in the loop, including issue-to-PR automation.
Generate, evaluate, and maintain Vitest and Playwright suites with AI assistance, and turn stack traces, source-map mysteries, and async failures into root causes faster.
Refactor at scale and migrate legacy JavaScript to typed TypeScript behind characterization tests, and generate documentation: JSDoc, type declarations, READMEs, and architecture decision records.
Recognize JS/TS-specific AI failure modes (hallucinated npm packages, stale framework APIs, type looseness), apply npm supply-chain and secret-handling guardrails, and contribute to team standards for cost, licensing, governance, rollout, and measuring real productivity impact.

Training Materials

Comprehensive courseware is distributed online at the start of class. All students receive a downloadable MP4 recording of the training.

Software Requirements

Node.js 24 LTS or later, access to your organization's chosen AI coding tools (such as GitHub Copilot, Claude Code, Codex, Cursor, Windsurf, or Gemini CLI; trials and free tiers are acceptable), VS Code, Git, and the GitHub CLI.

Training Topics

Foundations: How AI Writes Code

How LLMs generate code: tokens, context windows, and training data
The frontier models for coding: Claude, GPT, and Gemini compared
Capability tradeoffs: speed, cost, context size, and reasoning
Where AI excels in JS/TS work and where it reliably fails
Setting expectations: assistant, pair programmer, or junior engineer?

Setting Up and Configuring Your Chosen Tools

Accounts, seats, and enterprise policy: who gets access to what
Editor and CLI integration for the tools your organization selects
Model selection and switching: defaults, tiers, and per-task choices
Privacy and data controls: retention, training opt-outs, and telemetry
JS/TS-aware configuration: Node versions, package managers, and monorepos
Verifying your setup: a smoke-test workflow before daily use

Prompting and Context Engineering for JavaScript and TypeScript

Writing prompts that produce strict, modern TypeScript - not any soup
Steering toward current ECMAScript features and away from legacy patterns
Context strategies: monorepos, tsconfig settings, and framework conventions
Generics, utility types, and discriminated unions in prompts
Keeping generated code aligned with fast-moving framework APIs

Everyday Inline Assistance

Completions as a dialogue: writing code that invites good suggestions
When to accept, when to reject: building review reflexes
Comment-driven and JSDoc-driven prompting for completions
Types as steering: how annotations and generics sharpen suggestions
Avoiding autopilot: staying in command of code you sign

Chat-Driven Development

Explain, refactor, and generate: the core chat workflows
Scoping context: selections, files, and symbols - only what the question needs
Conversation hygiene: when to iterate and when to start fresh
From chat to edit: applying, reviewing, and adjusting suggested changes
Interrogating generated code: types, edge cases, and framework versions

IDE Assistants in Daily JS/TS Work

Deep-dive on your chosen IDE assistants (GitHub Copilot, Cursor, Windsurf, or others): completions, chat, edits, and rules/instructions files
The wider landscape: Aider, Cline, JetBrains Junie, and Amazon Kiro
Multi-file edits and chat-driven refactoring across modules
Component generation: steering toward your design system and conventions
JSDoc, type declarations, and documentation generation

Working with Project Context

CLAUDE.md and AGENTS.md in depth: what belongs, what doesn't
Rules and instructions files across tools: one convention, many formats
Encoding repo conventions: style, architecture, and testing norms
Team prompt libraries: capturing prompts that work and sharing them
Project context: tsconfig, package manager, workspace, and framework notes
Keeping context files current as the codebase evolves

AI-Assisted Code Reading and Comprehension

Onboarding to unfamiliar JS/TS codebases with AI guides
Generating explanations, call graphs, and architecture diagrams
Tracing async flows, events, and state through front-end and back-end code
Making sense of build tooling: bundlers, configs, and toolchains
Code archaeology: reconstructing intent from legacy code and history

Agentic Coding with Your Chosen Tools

The agentic loop: plan, act, observe, iterate
The agent landscape compared - Claude Code, Copilot agent mode, Codex, Cursor CLI, Windsurf Cascade, Gemini CLI - and how to choose
Plan mode and the supervision spectrum: permission prompts to auto mode
CLAUDE.md and AGENTS.md: package manager, tooling, and convention context
The verify loop: agents running tsc, ESLint, and the test suite
Issue-to-PR workflows: assigning work to cloud agents
MCP servers: connecting agents to internal tools and data

AI-Driven Testing in Depth

Generating Vitest suites: mocks, fixtures, and coverage gaps
Component and end-to-end testing with Playwright and AI assistance
API mocking and test data: factories and fixtures with AI help
Designing for testability: letting AI surface seams and dependencies
Mutation-style review: testing the tests AI writes
Agentic code review and pull request automation
Maintaining suites over time: updating tests as code changes

AI-Assisted Debugging in Depth

Turning stack traces and source maps into hypotheses
Async failures: unhandled rejections, race conditions, and stale closures
Debugging across the stack: browser DevTools, Node, and server logs
Log analysis and instrumenting code for better AI diagnosis
Knowing when the AI is guessing: validating proposed fixes

Refactoring at Scale and Legacy Modernization

Multi-file refactors: planning, executing, and reviewing with agents
Characterization tests as the safety net before any change
Migrating legacy JavaScript to TypeScript incrementally with agents
Framework and dependency upgrades: ESM migration and major-version bumps
Incremental modernization: strangler patterns over big rewrites
Keeping diffs reviewable: small steps over heroic changes

Documentation and Knowledge Work

JSDoc and TSDoc generation that matches project conventions
Type declarations and public API documentation
READMEs, how-to guides, and onboarding docs from real code
Architecture decision records: drafting and maintaining ADRs with AI
Keeping documentation honest: reviewing generated prose for drift

JS/TS-Specific Pitfalls and Verification

Hallucinated npm packages and typosquatting risk
Stale framework knowledge: verifying against current docs
Type looseness in generated code: strict mode and lint rules as gates
Bundle-size and performance review of generated code
ESLint, Biome, and Prettier as quality gates

Security, Licensing, and Governance

Prompt injection and untrusted content in agent workflows
Secret leakage: env files, client-side exposure, and context hygiene
npm supply-chain vetting: audit tooling and lockfile discipline
Licensing and IP status of AI-generated code
Organizational policy: approved tools, data boundaries, and audit trails
Review requirements: keeping humans accountable for shipped code

Measuring Impact, Cost, and Team Adoption

Tokens, model tiers, and budgets: managing cost without blunting value
Choosing the right model for the task: fast and cheap versus deep and slow
Re-evaluating the tool landscape: selection criteria, trials, and switching costs
Rollout patterns that work: champions, guilds, and paired onboarding
Metrics that matter - and vanity metrics that mislead
Adoption anti-patterns: mandates, leaderboards, and unreviewed merges