Anyone can say they use AI.This proves what you can build with it

Language models as code generators

• Tokens and tokenization
• Next-token prediction and autoregressive generation
• The practical meaning of a probability distribution over the vocabulary
• Why the useful mental model is a capable pattern-completer, not a reasoning oracle or a database

Training, inference, and knowledge

• The difference between training and inference
• What a model actually knows, and what it does not
• The knowledge cutoff, and why the model may not know a library version, API change, or framework released after it

The context window

• What it is, and why it functions as the model’s working memory
• Everything the model can reason about right now lives inside it
• Why what you put in, and leave out, changes the output

Reasoning models versus standard models

• What thinking or extended reasoning means in practice
• How reasoning models differ in behaviour
• When each type is the right choice for a task

Determinism and variability

• Why the same prompt can produce different output on different runs
• What temperature controls
• Why temperature zero does not guarantee identical results in production

Hallucination

• What it is, plausible, fluent, confident output that is simply false
• Why next-token generation produces it
• Why fluency and confidence are not evidence of correctness

Characteristic failures in code

• Hallucinated packages, APIs, and methods that do not exist
• Reversion to outdated patterns even when given current information
• Being confidently wrong
• Sycophancy, agreeing with a flawed premise rather than correcting it

Where AI excels and where it struggles

• Strong at boilerplate, exploring unfamiliar code, translation, first drafts, and well-specified bounded tasks
• Weak at novel architecture, deep project-specific context, and correctness at scale
• Weak at anything requiring lived experience of what breaks in production

Reading the evidence honestly

• How to interpret coding benchmarks, and their limits
• Why no single model is categorically best
• The productivity paradox, where measured output can diverge from how fast the work feels

Modes of assistance

• The distinct categories, autocomplete, chat assistants, inline edit, AI-native IDEs, and autonomous agents
• What each is for, and what changes as you move up

The autonomy ladder

• Levels of autonomy, from suggestion to full delegation
• Why higher is not always better
• Why matching the autonomy level to the task is a judgment call, not a ranking

Choosing a model for a task

• The axes that matter, capability, reasoning, speed, cost, context-window size, tool-use reliability, and multimodality
• Keeping more than one model in rotation, and routing each task to the one that handles it best

Deployment and data posture

• The practical differences between a consumer app, an API, and an IDE integration
• What each means for where your code and data go

Anatomy of an effective coding instruction

• Specificity, explicit constraints, and clear acceptance criteria
• The clarity heuristic, if a colleague with minimal context would be confused, so will the model
• Stating exactly what the output must contain

Context and examples

• Supplying the right context
• Using examples well, start with one and add more only when the output misses
• When examples help, and when they are unnecessary

Planning prompts

• Asking for a plan before code, the single highest-leverage prompting move
• Decomposing a task
• Asking the model to state its assumptions, flag uncertainty, and compare alternatives

Reasoning models versus standard models

• Brief, high-level goals for reasoning models; explicit, detailed instructions for standard ones
• Why think step by step is unnecessary for a model that already reasons internally

Iteration and anti-patterns

• Refining versus restarting a derailed thread
• Common anti-patterns, vague requests, over-stuffed prompts, and conflicting instructions
• Outdated techniques such as heavy role-play and tag-scaffolding on modern models

The context window as a budget

• Context as a finite resource with diminishing returns, an attention budget every token draws down
• Context rot, where quality degrades as the window fills, and a bigger window does not fix it
• The goal, the smallest set of high-signal tokens that does the job

Curation

• What to include, and what to exclude
• Why less, well-chosen context beats more
• Why how information is structured and presented matters, not merely whether it is present

Retrieval and codebase context

• File references and mentions
• Retrieval-augmented generation for code
• Embeddings and semantic code search
• Codebase indexing and repository maps
• Just-in-time retrieval versus pre-loading, and the hybrid that often wins

Rules, instructions, and memory

• Project rules and memory files, CLAUDE.md, AGENTS.md, .cursorrules, Copilot instructions
• Writing effective rules, scope, size, and why bloated files lose adherence
• The personal, repository, and organization layers
• Persistent memory and state across sessions

Connecting external context (MCP)

• What the Model Context Protocol is, and the problem it solves
• The client-server model, servers exposing data, tools, and workflows
• When to reach for MCP versus a rules file versus retrieval

Session management

• Compaction and summarization, automatic and manual
• Recognizing when to start a fresh session instead of continuing
• Sub-agents and context isolation, keeping a long task’s noise out of the main window

Requirements with AI

• Using AI to discover and clarify requirements
• Detecting ambiguity, missing cases, and unstated assumptions before any code exists

Acceptance criteria

• Turning requirements into testable criteria
• Functional versus non-functional requirements
• Constraints and business rules as first-class inputs

Specification-driven development

• The specification as a contract shared by humans and agents
• Spec-first versus spec-as-source rigour
• Executable specifications
• Preventing implementation drift, and traceability from spec to code to test

Why specs matter more with agents

• A vague instruction makes an agent faithfully build the wrong thing; a precise spec is the steering
• Catching the feature executed perfectly that is still not what was needed

AI as a design partner

• Generating design proposals, alternatives, and tradeoff analysis
• Pressure-testing an approach
• Producing architecture decision records

Decisions and accountability

• Which decisions must remain human, and why
• How to judge an AI’s architectural proposal rather than accept it
• Owning the shape of the system

Coherence at scale

• Holding a consistent architecture across many AI-made edits
• Working in large codebases and monorepos with AI
• Preventing the slow drift of many local changes

AI-legible codebases

• The repository as an interface to the AI
• Structure, naming, modularity, and boundaries an agent can navigate
• Documentation, conventions, and path-specific instruction files as part of the architecture

Legacy modernization

• The disciplined path for legacy systems, understand, document, characterize with tests, migrate, verify, not a blind rewrite
• Framework migrations

The build loop

• The loop, understand, plan, generate, inspect, run, test, evaluate, correct
• Why this beats prompt, copy, paste, ship

Codebase comprehension

• Using AI to understand unfamiliar code
• Tracing data flow and mapping dependencies before changing anything

Making changes

• Small bounded changes versus multi-file changes
• Refactoring with AI, and migrations
• Keeping scope and momentum without losing the thread of what changed

Mode selection in practice

• Choosing autocomplete, chat, inline edit, or an agent per task
• Recognizing the moment to stop delegating and take over yourself

Vibe coding, in its place

• Validating by outcome rather than reading the code
• Where it is acceptable, throwaway and exploratory work
• Why it is not the professional standard for anything that ships

What makes a tool agentic

• The agent loop, observe, plan, act, call a tool, read the result, iterate, and stop
• Why the ability to run code, not just write it, is the dividing line

Directing a single agent

• Plan-then-execute, read-only exploration then a plan you approve before execution
• The delegation contract, a clear objective, output format, tool guidance, and boundaries
• Reviewing the plan, not only the diff
• Knowing when to intervene, and when to stop the agent

Guardrails and permissions

• Allow, ask, and deny models matched to an action’s blast radius
• Sandboxing and least privilege
• Per-tool-use approval versus a single upfront plan approval

Tool use

• Tool and function calling, and tool schemas
• Read-only versus write tools
• Handling tool failures
• Why giving an agent the right tools is itself a design task

MCP for agents

• MCP as the way agents act on the outside world, not just read context
• Evaluating and trusting an MCP server
• Building your own server, in concept

Multi-agent and parallel work

• Orchestrator-worker architectures
• Running agents in parallel, isolated with git worktrees
• Sub-agents for context isolation
• Background, asynchronous, and cloud agents
• Judging when multi-agent genuinely helps, and when it merely multiplies cost

Customizing your agent

• Custom commands
• Hooks for validation and automation
• Packaging repeatable know-how as reusable skills

Reliability and cost

• Non-determinism, retries, timeouts, partial completion, and runaway loops
• Thinking in cost per successful task, not cost per request
• Concentrating review on the plan and the research, because errors propagate from a bad plan

Generating tests with AI

• Unit, integration, and end-to-end tests
• Test-driven development with agents, write the tests and let the agent make them pass
• Using a test suite as an agent’s guardrail and feedback loop

Test quality

• Meaningful tests versus tests that merely pass
• The risk of AI writing tests that assert nothing or quietly cheat
• Coverage read honestly
• Property-based testing and fuzzing with AI

The verification stack

• The escalating ladder, read the output, run it, run tests, static analysis, security analysis, acceptance checks, integration testing, production monitoring, human approval, continuous evaluation
• The more irreversible the action, the stronger the verification must be

Evaluating AI output and agents

• Moving from did it run to is it right, task success and graders
• Regression evaluation for agent workflows
• Why passing a test suite, or a benchmark, does not prove the solution is correct

Evidence-based debugging

• The loop, hypothesis, experiment, evidence, conclusion, not a guessed fix
• Feeding the model the right evidence, errors, logs, and stack traces

Root cause

• Reproducing a bug before fixing it
• Distinguishing symptom from cause
• Recognizing and breaking an AI debugging loop when the model thrashes on plausible non-fixes

Production and systems

• Using observability data with AI
• Distributed and production debugging
• Agentic incident investigation

Reviewing AI code

• Reading code faster than writing it, and reading it skeptically
• What to inspect specifically, assumptions, side effects, error handling, security, and edge cases
• Spotting hallucinated APIs, and the change that compiles and quietly does the wrong thing

Trust calibration

• Deciding when to trust, and when to verify
• The pull request as a verification boundary
• Reviewing large AI-generated diffs without rubber-stamping them

Standards and debt

• Holding standards and architectural consistency across AI edits
• Recognizing and paying down the technical debt that fast generation accumulates

Judgment and ownership

• Taste, experience, and the willingness to own the outcome, the parts AI does not supply
• Confident, honest calibration, where stating uncertainty is worth more than a confident miss

Security of AI-generated code

• The vulnerability classes AI reliably ships, injection, auth bypass, leaked secrets, and unsafe deserialization
• Reviewing AI code specifically for security
• The OWASP Top 10 for LLM applications, applied to coding work

Prompt injection

• Direct and indirect injection
• Injection through content an agent reads, web pages, files, and tool output
• Defenses, and handling untrusted input to an agent

The AI supply chain

• Hallucinated and typosquatted packages, and dependency confusion
• Verifying dependencies an AI adds
• Malicious MCP servers and skills as a new supply-chain surface

Secrets and data

• Not leaking secrets or proprietary source to a model
• Data retention and training policies across consumer apps, enterprise plans, and APIs
• Local and private models for sensitive work

Securing agents

• Permissions, least privilege, and sandboxing in depth
• Excessive agency, and how to bound it
• Auditing what an agent actually did

Delivery

• AI in CI/CD pipelines
• Automated AI code review in pull requests
• Automated dependency and vulnerability fixing
• Infrastructure-as-code and configuration with AI

Git and collaboration

• Commit messages, PR descriptions, and branching with AI
• Reviewing large diffs, and tracking change provenance
• Reverting AI changes cleanly

Documentation

• Generating and maintaining docs, ADRs, changelogs, and release notes
• Why documentation generated from wrong code is worse than none

Operations

• Log and metric analysis, incident response, and runbooks with AI
• Agent observability, capturing prompts, tool calls, and steps, to answer why the agent did that
• The irreversibility-to-approval rule, applied to deployment

Shared practice

• Shared instructions, skills, and MCP servers
• Onboarding a team to AI-assisted development
• The personal, repository, and organization instruction layers

Governance

• Approved tools and data classification
• IP and licensing of AI-generated code
• Provenance and human-approval boundaries
• Writing an AI usage policy that enables rather than blocks

Measuring impact

• Frameworks such as DORA and SPACE applied to AI-assisted teams
• Measuring outcomes rather than output volume
• Reading the real evidence, including that AI can make work feel faster while measuring slower

The professional’s role

• The shift from writing code to specifying, directing, and verifying it
• Skill atrophy and over-reliance, and when not to use AI
• The ethics and responsibilities that come with it
• Staying current as the frontier keeps moving