Competency map

Concepts

Explains how a language model produces text and where it fails

• Explains tokens, context and sampling in plain words base
• Names the common ways output goes wrong and why base
• Explains what grounding and retrieval add and what they do not fix base

Writes prompts that get reliable results

• Turns a vague request into instruction, context, example and format base
• Improves a result by changing the prompt, not by retrying base
• Asks for output in a shape the next step can use base

Recognizes an agent, its tools and its degree of autonomy

• Tells a chat assistant from an agent by what it can do unprompted base
• Places a product or workflow on the autonomy scale base
• Describes the observe, think, act loop and the tools in it base
• Follows one prompt through its model requests and names the part of the agent behind each step base

Reasons about what a model request costs and why

• Reads the token counts of a request and says where its cost comes from base
• Explains why a session costs more per request as it grows base
• Chooses an effort level for a kind of work and keeps it fixed base
• Explains what prompt caching saves and what breaks it expert

Safety

Uses AI safely with confidential and personal data

• Decides what may go into a prompt and what may not base
• Discloses AI use where the audience expects it base
• Respects licenses and attribution in AI-assisted output base

Verifies AI output before relying on it

• Checks claims and sources on anything that leaves their desk base
• Spots agreement that is not evidence base
• Matches the depth of checking to the cost of being wrong base
• Builds verification into a team's routine rather than their own expert

Judges the risk of letting an agent act

• Names what an agent action can reach and break base
• Chooses where a human must approve base
• Recognizes prompt injection and data exfiltration paths base
• Sets policy, logging and escalation for agents in an organization expert

Using agents

Delegates a task to an agent and checks the result

• Writes a brief with goal, context, limits and done-criteria base
• Chooses how much the agent may do before checking in base
• Reviews the result against the brief, not against a feeling base
• Adjusts the brief when the work reveals new information base

Chooses the right tool and autonomy level for a job

• Picks chat, agent or automation for a task and says why base
• Picks a model for a task by testing fit, cost and speed base
• Names the steps that stay human and why base
• Re-applies judgment when the tool level rises expert

Coding with agents

Ships a change with a coding agent through plan, implement and verify

• Runs a session from setup to a reviewed diff base
• Works in small increments, sequenced for early feedback base
• Keeps every change reversible base
• Gives the agent the files, constraints and limits the task needs base
• Keeps their own understanding of the code as the agent produces more of it expert
• Chooses deliberately what each phase of work starts with, including the starting context expert

Specifies work well enough for an agent to implement and for anyone to verify

• Judges whether something should be built before building it base
• Defines what a successful outcome requires base
• Decomposes a problem into components with clear dependencies base
• Designs how the work will be verified before it is built base
• Reaches a shared design by having the agent interview them before planning base
• Settles a design question with a throwaway prototype expert

Draws on topics from other areas: Decomposing work

Verifies agent-written code before trusting it

• Reviews code they did not write, against the specification base
• Observes the running system and isolates a fault systematically base
• Turns a check into a bounded, self-checking loop base
• Chooses a deterministic gate over a model's review to block work base
• Screens agent output for security and supply-chain problems base
• Has a change reviewed in a fresh session and weighs the findings base

Draws on topics from other areas: Agent risk

Works with agents alongside a team

• Attributes agent work honestly in commits and reviews base
• Follows the team's review and CI norms for agent changes base
• Keeps specs and tickets where the team and the agent can both reach them base
• Turns recurring review findings into written standards or automated checks base
• Runs several agent sessions without losing coherence expert
• Sets the team's practice for agent use expert

Customizing agents

Configures an agent for a project

• Writes instructions that remove a recurring agent mistake base
• Sets permissions to the least the work needs base
• Adds a hook that enforces a rule the instructions cannot base
• Decides for each piece of guidance whether to load it or point at it base
• Manages what the agent carries between sessions expert
• Prunes instruction files line by line expert

Writes a reusable agent skill

• Chooses between a skill, a tool and an instruction for a need base
• Packages a repeatable procedure as a skill another person's agent can use base
• Structures a skill so the agent loads only what it needs base
• Reads a plugin's parts before installing it and takes only what is needed base
• Chooses who invokes a skill and where it is installed base

Adopts a published skill set without giving up control of the project

• Vets a published skill set before installing it, as they would a dependency base
• Adopts a few skills at a time and checks each one's effect and context cost base
• Keeps the project's own instructions, hooks and permissions in charge when a skill set disagrees base

Connects an agent to tools and data safely

• Adds a tool via MCP or CLI with least privilege base
• Explains the token and risk cost of a tool before adding it base
• Hardens a tool connection against injection and exfiltration expert
• Inspects the requests to see what tools and context cost, and keeps request logs local expert

Draws on topics from other areas: Agent risk

Building agents

Builds a tool-using agent loop

• Defines a tool with a schema the model uses correctly base
• Implements the loop with error handling and a stop condition base
• Adds retrieval or memory and knows when basic RAG is enough base
• Decides which tools must wait for a person's approval and what that person is shown base
• Rebuilds the loop on an agent SDK and explains what the SDK took over expert

Evaluates an agent's quality systematically

• Turns "good" into scorable criteria base
• Builds a representative input set with expected qualities base
• Grades the path the agent took, not only the final answer base
• Chooses what to fix from counted failures base
• Chooses metrics that cannot improve without the real quality improving expert
• Grows the evaluation set from what goes wrong in real use expert

Designs and orchestrates multi-agent systems

• Picks a design pattern for a task and says why base
• Justifies the coordination cost of more than one agent base
• Composes patterns and names the failure modes of the composition expert

Runs an agent in production with guardrails

• Gates a deploy on evaluation results base
• Layers policy, filtering and monitoring around the agent base
• Mitigates injection, exfiltration and over-permission in a running agent base
• Manages cost and rolls out changes without breaking users expert

Draws on topics from other areas: Governance and oversight, Connecting tools with MCP

not startedin progressfinished

Six areas in two rows of three, each headed by the course that teaches it. A box is a competency: something you can do after the course. The lines in a box are its learning objectives, each tagged base or expert. A box or a line takes the color of the lessons that serve it. Click a competency or an objective for its behaviors and lessons. For the topics the site teaches, see the topic map.