roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Interview for AI red team roles knowing how LLM systems break and how to prove it. Covers LLM attack techniques, adversarial ML, offensive security tooling, and the API and auth attack surface.
6839 of 6839 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 6839 new. 0 cut, outside your plan.
An AI red team loop is usually built around a target, a deliberately weak chatbot as a take-home or an agent with tools for a live hour, with the brief to make it do something its owner forbade, show that the result repeats, and write it up so the owning team can fix it. The rest of the loop is more conventional: a Python coding round, often a probe harness against a model API rather than an algorithm problem; a technical conversation on attack technique; from middle level up, a round on threat modeling or scoping an engagement; and a behavioral interview. The conversation separates vocabulary from mechanism. Anyone can name prompt injection; the question is why a sentence inside a retrieved PDF ends up as a tool call, which trust boundary failed when it did, and why that is a different bug from a jailbreak that talks a model past its own policy. Follow-ups go to the exfiltration path once an injection lands (a Markdown image whose URL carries the conversation out), to why a filter tuned on plain English passes a Base64 or low-resource-language payload, and to what lets a pickled checkpoint run code the moment it is loaded. What marks a senior candidate is the harness rather than the exploit: a scorer that decides success without a human reading each transcript, a fixed probe set re-run against each model and prompt revision, severity graded by what the attack reached (a tool with write access, another user's data, or one off-policy sentence), and a report the product team can retest against. Interviewers also listen for restraint: scope, rules of engagement, and what you do with a finding that touches real user data.
An attack on a system you cannot describe is guesswork, so the [LLM methods](/topics/found-ai-llm-methods) module opens the plan: how a model gets wired to tools, retrieved documents and a safety layer, since most later techniques abuse one of those wires. The same module carries the [evaluation](/topics/found-ai-engineering-evaluation) and [tracing](/topics/found-ai-engineering-observability) a red-team harness reuses as its scoring machinery. The next stretch is the working toolkit: [Python](/topics/lang-python) for probe scripts and harnesses, [Bash](/topics/lang-bash) for the hosts you work from, [Git](/topics/dev-git) for what you hand over, and the [algorithms](/topics/found-dsa) a coding round may still grade. Then the plan goes to the model itself: the [ML frameworks](/topics/ai-ml-frameworks), because adversarial examples are computed through a framework's gradients, and the Hugging Face layer, ending in [tokenizers and chat templates](/topics/ai-huggingface-tokenizers), where the special tokens separating system text from user text live, and with them a class of injection. [Retrieval stores](/topics/db-vector-concepts) follow as the layer you will be breaking, where a planted document waits for the query that pulls it into the model's context, and a deleted one can still be served until the delete reaches every replica. [Application security](/topics/found-appsec) sits just before the attacks so that injection, broken authorization and weak cryptography are familiar in their classical form first. The center of the plan is the attack stretch: [LLM attack techniques](/topics/sec-ai-llm-attacks), where [agent, tool and MCP attacks](/topics/sec-ai-llm-attacks-agent-tool-attacks) carry the most weight for anyone testing agents; [adversarial ML](/topics/sec-adversarial-ml), aimed at the weights and training data rather than the prompt; and [model artifacts](/topics/sec-supply-chain-registry-trust-model-artifacts), what a downloaded weights file may do when it is loaded. Tooling follows the technique it automates: the [intercepting proxy](/topics/sec-burp-suite-proxy-scope) puts you between the chat UI and its API, the [practice labs](/topics/sec-ctf-platforms) are the practice ground, and [AI red-team tooling](/topics/sec-ai-redteam-tools), PyRIT, garak and promptfoo first, runs the attacks at scale and carries the reporting that closes an engagement. The plan then steps out to the plumbing around the model: [federated identity](/topics/proto-auth-identity), because an agent acts on someone's token; [API styles](/topics/proto-api-styles) from REST to [MCP](/topics/proto-mcp); and [web protocols](/topics/proto-web-transport), where a chat widget's origin and cookie rules decide what a leaked response can reach. The last stretch turns from the system to the candidate: the [behavioral round](/topics/found-behavioral) and the stages a hiring process runs through.
A web penetration tester arriving here already owns the proxy, the application-security vocabulary and the identity protocols; the time goes into the opening module and the attack stretch, adversarial ML above all, which has no counterpart in web testing. An AI or ML engineer crossing the other way can move quickly through the opening and framework modules and should slow down at application security, the proxy and the API attack surface, where an interviewer expects you to find the authorization bug behind the model, not only the injection in front of it. Close to the interview, scope the plan the way you would scope an engagement: importance belongs at must know and nothing below it, level on the band you are applying at, and what survives that cut is mostly attack technique and red-team tooling, which is also where interviewers spend their follow-ups. Given months, take study order off by frequency and onto by topics, and work the attack stretch against a deliberately vulnerable target rather than from the page: the follow-up question is how you reproduced the finding, and a taxonomy has no answer to that. The practice labs appear here as practice ground, not as a syllabus. The plan has no module on network reconnaissance, host exploitation or privilege escalation, and none on the detection and incident response a blue team runs; the [Cyber Security Expert roadmap](/roadmaps/cyber-security) covers that classical penetration test around the AI system. Modeling a system's threats before the first probe is sent is a method of its own, in [Threat Modeling](/roadmaps/threat-modeling).
An AI red team loop is usually built around a target, a deliberately weak chatbot as a take-home or an agent with tools for a live hour, with the brief to make it do something its owner forbade, show that the result repeats, and write it up so the owning team can fix it. The rest of the loop is more conventional: a Python coding round, often a probe harness against a model API rather than an algorithm problem; a technical conversation on attack technique; from middle level up, a round on threat modeling or scoping an engagement; and a behavioral interview.
The conversation separates vocabulary from mechanism. Anyone can name prompt injection; the question is why a sentence inside a retrieved PDF ends up as a tool call, which trust boundary failed when it did, and why that is a different bug from a jailbreak that talks a model past its own policy. Follow-ups go to the exfiltration path once an injection lands (a Markdown image whose URL carries the conversation out), to why a filter tuned on plain English passes a Base64 or low-resource-language payload, and to what lets a pickled checkpoint run code the moment it is loaded.
What marks a senior candidate is the harness rather than the exploit: a scorer that decides success without a human reading each transcript, a fixed probe set re-run against each model and prompt revision, severity graded by what the attack reached (a tool with write access, another user's data, or one off-policy sentence), and a report the product team can retest against. Interviewers also listen for restraint: scope, rules of engagement, and what you do with a finding that touches real user data.
An attack on a system you cannot describe is guesswork, so the LLM methods module opens the plan: how a model gets wired to tools, retrieved documents and a safety layer, since most later techniques abuse one of those wires. The same module carries the evaluation and tracing a red-team harness reuses as its scoring machinery. The next stretch is the working toolkit: Python for probe scripts and harnesses, Bash for the hosts you work from, Git for what you hand over, and the algorithms a coding round may still grade.
Then the plan goes to the model itself: the ML frameworks, because adversarial examples are computed through a framework's gradients, and the Hugging Face layer, ending in tokenizers and chat templates, where the special tokens separating system text from user text live, and with them a class of injection. Retrieval stores follow as the layer you will be breaking, where a planted document waits for the query that pulls it into the model's context, and a deleted one can still be served until the delete reaches every replica.
Application security sits just before the attacks so that injection, broken authorization and weak cryptography are familiar in their classical form first. The center of the plan is the attack stretch: LLM attack techniques, where agent, tool and MCP attacks carry the most weight for anyone testing agents; adversarial ML, aimed at the weights and training data rather than the prompt; and model artifacts, what a downloaded weights file may do when it is loaded.
Tooling follows the technique it automates: the intercepting proxy puts you between the chat UI and its API, the practice labs are the practice ground, and AI red-team tooling, PyRIT, garak and promptfoo first, runs the attacks at scale and carries the reporting that closes an engagement. The plan then steps out to the plumbing around the model: federated identity, because an agent acts on someone's token; API styles from REST to MCP; and web protocols, where a chat widget's origin and cookie rules decide what a leaked response can reach. The last stretch turns from the system to the candidate: the behavioral round and the stages a hiring process runs through.
A web penetration tester arriving here already owns the proxy, the application-security vocabulary and the identity protocols; the time goes into the opening module and the attack stretch, adversarial ML above all, which has no counterpart in web testing. An AI or ML engineer crossing the other way can move quickly through the opening and framework modules and should slow down at application security, the proxy and the API attack surface, where an interviewer expects you to find the authorization bug behind the model, not only the injection in front of it.
Close to the interview, scope the plan the way you would scope an engagement: importance belongs at must know and nothing below it, level on the band you are applying at, and what survives that cut is mostly attack technique and red-team tooling, which is also where interviewers spend their follow-ups. Given months, take study order off by frequency and onto by topics, and work the attack stretch against a deliberately vulnerable target rather than from the page: the follow-up question is how you reproduced the finding, and a taxonomy has no answer to that.
The practice labs appear here as practice ground, not as a syllabus. The plan has no module on network reconnaissance, host exploitation or privilege escalation, and none on the detection and incident response a blue team runs; the Cyber Security Expert roadmap covers that classical penetration test around the AI system. Modeling a system's threats before the first probe is sent is a method of its own, in Threat Modeling.