Decide what the agent can reach, because nobody will be there to ask.

DevOps is where AI coding agents stop being an editor feature and become a pipeline step. All three run headless, and Claude Code and Codex emit structured JSON, which makes them usable in CI — and makes an exact command allowlist and a sandbox the guardrails that matter, because there is nobody present to approve anything.

$59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.

Pages picked for this work
6
Steps on the reading path
16
Questions in the free scorecard
25
By-role data last updated
2026-08-17

Pages: CI/CD pipeline recipes, Docker patterns, Kubernetes patterns, Infrastructure as code, Monitoring and logging, Running agents in CI/CD.

One change, two ways to work.

One scheduled run, drawn two ways: in an editor with you there, and in a pipeline with nobody.

  • Written by you
  • Read by you
  • Agent and checks

In an editor, with you there

A prompt can reach you.

In an interactive session you answer the prompts that remain, and auto mode or an auto-review reviewer can take some of them, so a prompt still protects something.

  1. Prompt You answer
  2. Prompt You answer
  3. Prompt You answer
  4. Prompt You answer

As a pipeline step

Policy first, then the run.

A scheduled run has nobody to answer a prompt, so the layer that works is an exact allowlist: anything unlisted is denied. The run sits in a sandbox, on a disposable runner with scoped tokens.

Policy

Allowlist and sandbox

Set before the run: an exact command allowlist, a sandbox and a disposable runner with scoped tokens. Hooks add checks only where the session loads them.

You write and read

The headless run

  • Headless run
  • Tool allowlist
  • Turn limit
  • Required checks

Works inside those limits and emits structured output.

Agent writes, checks read

Result

JSON the step can branch on

Claude Code and Codex emit JSON on request, so a step can act on a result instead of only logging it.

You read

Approval prompts stop protecting anything. An interactive session has a person for the prompts that remain; a scheduled one has nobody to answer, so what a command can reach has to be decided in advance: an exact allowlist, a sandbox and a disposable runner with scoped tokens. Hooks add checks in a session that loads them, but Claude Code’s --bare mode, the one the CI guide uses, skips them. Structured output becomes the difference between a CI step that can branch on a result and one that can only log it. Both Claude Code and Codex emit JSON on request.

Drawing
One change, two ways to work.
Source
Drawn from the by-role text for DevOps engineers, last updated 2026-08-17; the limits per run are from the Claude Code CI integration guide, the approval layers from the permissions and sandboxing guide.
Note
An illustration of the by-role data, not a measurement

The failures your tests do not catch.

Each recipe opens with the failure it exists to prevent. Here are 5, in the recipes’ own words, with the page that fixes them.

  1. The scene
    “Your deploy passed every check and still shipped a critical CVE. The tests were green and the image built, but the scan step only uploaded a report, so nothing in the pipeline could say no.”

    The page that fixes it CI/CD pipeline recipesCopy-paste recipes that make Claude Code, Codex, and Cursor generate CI/CD pipelines with gates you prove can fail: scans, pinned actions, gated deploys.

    Open CI/CD pipeline recipes 2026-10-03

  2. The scene
    “Your image is 1.2 GB, CI rebuilds every dependency on each push, the scanner lists 40 CVEs in the base layer, and the container takes 10 seconds to stop because PID 1 ignores SIGTERM.”

    The page that fixes it Docker patternsRecipes for agent-written Dockerfiles, Compose files and image CI with Claude Code, Codex and Cursor, plus a script that proves each image before you merge.

    Open Docker patterns 2026-10-12

  3. The scene
    “Your rollout just took the API down. The readiness probe went green before the Postgres pool finished warming, so traffic moved onto pods that returned 500s, and the manifest came from an agent that never knew the pool needs eight seconds.”

    The page that fixes it Kubernetes patternsHave Claude Code, Codex, or Cursor write Kubernetes manifests and Helm charts, then prove them with kubeconform, server dry-run, and diff gates.

    Open Kubernetes patterns 2026-10-12

  4. The scene
    “You inherit a Terraform repository with one 900-line main.tf, hardcoded CIDR blocks, a provider pinned two majors back, and a terraform plan that wants to replace the production RDS instance.”

    The page that fixes it Infrastructure as codeRecipes for agent-written Terraform, CloudFormation and Pulumi, with plan-only credentials, a machine-checked plan gate and a human sign-off on destroys.

    Open Infrastructure as code 2026-10-12

  5. The scene
    “Your checkout API threw 500s for an hour last night while every dashboard stayed green, because the alerts watched CPU instead of the error rate.”

    The page that fixes it Monitoring and loggingAgent recipes for golden-signal and SLO burn-rate alerts, Alertmanager routing, log-trace correlation and tail sampling, each proven by a machine check.

    Open Monitoring and logging 2026-10-12

Scenes are the opening scenarios of the pages and are written as examples, not as reader reports. Quotations are trimmed. The pages are documentation pages and come with the Toolkit.

Your reading path, in the order it pays off.

From the 16 steps on the developer path, 6 picked for agents that run with nobody present: what they may reach, checks they cannot weaken, a pipeline step. The numbers are each step’s place in the full path, and each one says what you can show when it is done.

  1. Step 1 of 16 Free

    The Autonomy Ladder: Which Level Is Your Workflow At?

    Place your current workflow on the ladder, so every later step is a move up one rung.

    Done whenYou can name your level and the one habit that keeps you on it.

  2. Step 4 of 16 Toolkit

    Permissions, sandboxes and approval modes across Claude Code, Codex and Cursor

    Decide what the agent may run without asking before you let it run longer.

    Done whenA committed permission policy and a sandbox for anything with network or secrets.

  3. Step 7 of 16 Toolkit

    Test: give the session a feedback loop

    A single-command feedback loop lets the agent prove its own work before you look.

    Done whenThe agent runs the loop and reports exit status on every task.

  4. Step 8 of 16 Toolkit

    Protecting the oracle: checks the agent cannot edit

    Tests the agent can edit are not evidence; lock the checks it must not weaken.

    Done whenA hook or CI rule that fails when protected tests change.

  5. Step 14 of 16 Toolkit

    Reviewing an agent's pull request without reading every line

    Review an agent pull request by risk class and evidence, with a short escalation list.

    Done whenA review checklist the review agent runs and you only escalate from.

  6. Step 15 of 16 Toolkit

    From issue to pull request with no hands on the keyboard

    Once the gates hold, let a well-shaped issue become a pull request without you.

    Done whenOne issue closed by a pipeline run you did not start by hand.

Steps and “done when” lines: the developer reading path, 16 steps and 2 further reading, last updated 2026-10-12. The ladder pages are free; every other step is marked.

Read the whole path

Where your DevOps work sits on the ladder.

Dan Shapiro’s levels describe how much of the work you hand to an agent. Each row shows what one pipeline change looks like at a rung the scorecard can place you on.

Not sure which row is yours?

The AI Dev Score asks 25 questions in about 8 minutes, scores 6 sections and gives you a 30/60/90-day plan for the next rung. Free.

Take the AI Dev Score

No account, no card. An email only at the end, and only if you want the full playbook.

  1. 4

    The engineering team

    “leave for 12 hours, and check to see if the tests pass”

    One pipeline changeThe agent runs as a pipeline step under an exact allowlist and a sandbox. A gate decides whether the result merges, and you read the gate output. A change to the pipeline’s own checks, the oracle, still gets a named reader.

    Where the toolkit points
  2. 3

    The developer

    “Your life is diffs.”

    One pipeline changeThe agent writes the workflow or the manifest and you read every line of the YAML.

    The valley, levels 2 and 3
  3. 2

    The junior developer

    “feels like you are done. But you are not done”

    One pipeline changeYou and the agent write the Dockerfile together, one change at a time, and you run each one.

  4. 1

    The coding intern

    “you offload specific, discrete tasks to your AI intern”

    One pipeline changeYou hand over one command or one resource block, and you paste the result into your own file.

Level names and quotations: Dan Shapiro, “The Five Levels: from Spicy Autocomplete to the Dark Factory”, 2026-01-23 (opens in a new tab). The ladder runs from Level 0 to Level 5 and the scorecard places you on 1 to 4. The “One pipeline change” column is our illustration.

Your first week, planned.

  1. Day 1

    Generate your Setup Pack.

    Answer 9 questions about your stack and tools, including language, framework, package manager and test runner. Your agent runs INSTALL-PROMPT.md and checks each setting against what you have installed. About 20 minutes. The Setup Pack is included in the Toolkit.

  2. Days 2 to 5

    Hand over one real change.

    Pick one pipeline or manifest change. Write intent.md and spec.md, set the allowlist and the sandbox first, have the agent draft plan.md and accept it before anything changes, let the agent build and stop on the gate, then read the gate output. A named person reads any change to the workflow itself.

  3. By day 30

    Decide with evidence.

    You have one change done the new way. If it did not change how you work, ask for a refund before day 30.

Buy the Toolkit

The Toolkit includes the guides, the Setup Pack and all eight books, for 12 months. $59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.

Questions about this work.

Something else? Write to support@developertoolkit.ai.

How do you run an AI coding agent in CI?

Claude Code takes claude -p "task" with --output-format json; Codex takes codex exec "prompt" with codex exec --json; Cursor exposes CLI, SDK and Cloud Agents. All three also support scheduled automations.

What stops an agent doing damage in an unattended run?

Not approval prompts: there is nobody to answer them. What stops it is decided before the run: an exact command allowlist (dontAsk in Claude Code, or never with a profile in Codex), a sandbox, and a disposable runner with scoped tokens. Hooks add checks in a session that loads them, but Claude Code’s --bare mode skips hooks, so do not make them the only guard.

What do I read instead of the diff?

The evidence the change carries: the spec delta, the acceptance results, the strength of the oracle and runtime signals from a running build. A named person still reads the code for authentication, money, schema and migrations, changes to the tests themselves, and anything no check covers.

I only use one of the three tools.

That works. Where Claude Code, Codex and Cursor differ, the guides and recipes show a tab for each, so you read the one for your tool.

Decide in advance. Let the pipeline run.

Within the 30-day refund window, put one agent step in a pipeline, behind a gate, on your own service.

$59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.