Vaughan | Agentic Coding with OpenAI Codex CLI | E-Book | www.sack.de
E-Book

E-Book, Englisch, 670 Seiten

Vaughan Agentic Coding with OpenAI Codex CLI

Build intelligent agent workflows using Agentic Engineering, MCP, hooks, and delivery automation
1. Auflage 2026
ISBN: 978-1-80834-888-4
Verlag: Packt Publishing
Format: EPUB
Kopierschutz: 0 - No protection

Build intelligent agent workflows using Agentic Engineering, MCP, hooks, and delivery automation

E-Book, Englisch, 670 Seiten

ISBN: 978-1-80834-888-4
Verlag: Packt Publishing
Format: EPUB
Kopierschutz: 0 - No protection



Agentic Coding with OpenAI Codex CLI is a comprehensive guide to agentic AI development with OpenAI's command-line coding agent. Across six parts, you'll move from first principles to production workflows and team-scale practice: prompting and AGENTS.md configuration, approval modes and kernel-level sandboxing, model selection, context and cost management, MCP servers, hooks, skills, sub-agents and orchestration, worktrees, CI/CD integration, security hardening, and enterprise deployment.
Later chapters cover debugging and testing agentic workflows, AI code review, practical engineering guides (codebase migration, backend, frontend, and infrastructure as code), and the bigger picture: benchmarks, competing tools, harness engineering, and how to structure an agentic engineering team.
Whether you're a solo developer looking to multiply your output or an engineering lead rolling out agentic workflows across a team, this book gives you the mental models and practical techniques to work effectively with AI coding agents.
It draws on real-world experience and community insights, and every chapter includes learning objectives, worked examples, and hands-on exercises.

Vaughan Agentic Coding with OpenAI Codex CLI jetzt bestellen!

Autoren/Hrsg.


Weitere Infos & Material


Preface


I Started This on a Train


The 07:02 from Audley End to Liverpool Street takes fifty-eight minutes, getting you into London at 08:00 unless something has gone wrong at Tottenham Hale. On a Tuesday in November 2025 I had my laptop open, a half-decent mobile data connection, and a vague intention to finally take Codex CLI seriously. I’d installed it a couple of weeks earlier, run a few commands, shrugged, and gone back to whatever I was already doing, probably something fun with Gemini Nano Banana. That morning I had a real problem: a Node service I’d written six months ago had started behaving oddly in staging, and I hadn’t looked at it since. I didn’t even have the repo fresh in my head.

I pointed Codex CLI at the project directory, described the symptom, and watched.

What happened next is the reason you’re reading this book. It didn’t just suggest a fix. It read the source files, traced the execution path, ran the test suite, found a second problem I hadn’t mentioned, wrote a failing test for it, fixed both issues, and asked me whether it should open a pull request. By the time we pulled into Tottenham Hale (where, yes, something had gone wrong) I had a clean diff, a short explanation of the root cause, and a slight sense of unease about what I’d just seen.

I’ve been using AI coding assistants since the early Copilot days1 I’ve gone through phases with ChatGPT in a browser tab, Claude in a sidebar, various Copilot flavours, Cursor, Windsurf, and a handful of others whose names I’ve already forgotten. They’ve all been useful in the way that autocomplete is useful. This was different. Not because it was smarter, exactly, but because it was : reading context, taking actions, managing state, recovering from errors, rather than responding. The distinction sounds subtle. It isn’t.

1 GitHub Copilot, the original AI pair-programming tool, was first introduced in 2021 as a technical preview and is powered by generative AI models developed by GitHub, OpenAI, and Microsoft. https://github.com/features/copilot

That’s when the book became necessary.

What Changed My Mind


What changed my mind wasn’t any single impressive output. It was understanding the architecture.

Most AI coding tools are, at their core, sophisticated text completers with a context window. You give them code; they give you more code. The quality varies, the context window keeps getting bigger, the integrations get slicker, but the underlying model is reactive. You prompt, it responds. You accept or reject. You prompt again.

Codex CLI is built on a different premise. It’s an agent loop. You give it a goal, and it plans, executes, observes the results, adjusts, and continues until it’s done or it’s stuck. It has real tool use: it can read and write files, run arbitrary shell commands, execute tests, call external APIs.2 It can spawn sub-agents to work in parallel on independent sub-tasks. It carries context across steps within a session. It knows when to ask for clarification and when to just get on with it.

2 The official Codex CLI documentation describes the agent’s tool use capabilities, including file read/write, shell command execution, and API calls. https://developers.openai.com/codex/cli

That architecture matters because it changes what the tool is good for. Autocomplete is good at the line-by-line. Chat is good at the question-and-answer. Agentic execution is good at the , the thing that has a beginning, a middle, and an end, that requires reading several files and running several commands and making several decisions along the way. Refactoring a module. Adding a feature end-to-end. Diagnosing a failing build. Those are the things that used to eat your afternoon. Those are the things Codex CLI is built for.

Much of the breathless commentary about AI coding tools, and there is a lot of it, most of it overstated, misses this distinction. People benchmark autocomplete quality, or measure how often a model suggests the right function name. That’s fine, but it’s measuring the wrong thing. The interesting question isn’t whether the model can write a sorting algorithm. It’s whether the tool can sit alongside you in your actual workflow, your repo, your tests, your CI system, your conventions, and do useful work with real autonomy. Codex CLI’s answer to that question is the most interesting I’ve seen.

This book is my attempt to explain why, and to teach you how to use it properly.

Who This Book Is For


I wrote this for mid-to-senior software engineers who are already comfortable with AI-assisted development and are wondering whether agentic tools change the picture. If you’ve been using GitHub Copilot for a while, or you already work with an agentic tool like Claude Code, you understand what these tools are good at and where they fall short, and you want to get more out of the agentic approach: this is the book for you.

You should be comfortable in a terminal. Codex CLI is a command-line tool, and this book treats it as one. There’s no GUI, no plugin, no sidebar. Everything happens in your shell. If that sounds appealing rather than alarming, you’re in the right place.

You don’t need deep expertise in machine learning or large language models. I’ll explain what you need to know about how the underlying models work to use Codex CLI effectively, but this isn’t an ML textbook. What I’m assuming is engineering experience: the ability to read a codebase, reason about system behaviour, debug under uncertainty. Those skills translate directly.

This book is not for managers who want to understand the AI landscape, or for non-technical readers curious about where software development is heading. There are good books for those audiences. This isn’t one of them. I’ve written for engineers, and I’ve tried to be concrete and specific in the way that engineers find useful.

One more thing: I’m writing from the perspective of someone who uses this daily, working across enterprise delivery, research, and engineering teams. I’ve run Codex CLI on production codebases, on greenfield projects, in CI pipelines, and in local development. My opinions in this book are grounded in that use, not in benchmarks or demos.

What You Won’t Find Here


I want to be honest about scope. Books that oversell their coverage do readers a disservice.

This is not a general introduction to prompt engineering. There are plenty of those, and some of them are excellent. This book assumes you can write a decent prompt and focuses instead on the specific patterns and idioms that work well with Codex CLI’s agentic model.

This is not an LLM textbook. I won’t be explaining attention mechanisms, transformer architectures, or how current frontier models are trained. Where the underlying model matters, and it does matter in specific ways, I’ll explain what you need to know. But understanding neural networks is not a prerequisite for using Codex CLI effectively.

This is not a market survey. I’m not going to spend chapters comparing Codex CLI to Cursor, Devin, Aider, Claude Code, and every other tool in the landscape. That comparison would be out of date before the book was printed. What I will do is explain what distinguishes the agentic approach from the alternatives, and let you draw your own conclusions about what that means for the tools you already use.

What you will find here is one tool, covered deeply, from someone who has used it daily for several months, with strong opinions about what works and what doesn’t.

How This Book Is Organised


The book is divided into six parts.

Part 1: Grounding puts Codex CLI in context and establishes the persistent context the agent always reads. What is it, where did it come from, how do you install and prompt it, and what belongs in ? If you’re completely new to the tool, start here. If you’ve already been using it for a while, you might skim Part 1 and come back to specific chapters when they’re relevant.

Part 2: Guardrails cover the configurable levers that steer and constrain a run: approval modes, model selection, context management, MCP integrations, and the hooks system. This is the part you’ll return to most often as a reference. I’ve tried to write it so that individual chapters stand alone.

Part 3: Scaling Up explains how to go beyond the defaults. Skills, sub-agents, multi-agent orchestration, cost management, and CI/CD integration. This is where things get interesting if you have specific workflows or constraints.

Part 4: Production addresses the questions that come up when you move from personal use to team use. Security hardening, enterprise configuration, debugging, and testing strategies.

Part 5: Practitioner Guides is the applied section, with specific, detailed walkthroughs of using Codex CLI for code review, codebase migration, infrastructure as code, frontend engineering, Python teams, and worktree-based isolation. Each chapter in this part follows a real task from start to finish.

Part 6: The Bigger Picture steps back from individual workflows and examines the architecture: benchmarks, competing tools, harness engineering, and the emerging role of the agentic engineering pod. These chapters assume you have worked through the...



Ihre Fragen, Wünsche oder Anmerkungen
Vorname*
Nachname*
Ihre E-Mail-Adresse*
Kundennr.
Ihre Nachricht*
Lediglich mit * gekennzeichnete Felder sind Pflichtfelder.
Wenn Sie die im Kontaktformular eingegebenen Daten durch Klick auf den nachfolgenden Button übersenden, erklären Sie sich damit einverstanden, dass wir Ihr Angaben für die Beantwortung Ihrer Anfrage verwenden. Selbstverständlich werden Ihre Daten vertraulich behandelt und nicht an Dritte weitergegeben. Sie können der Verwendung Ihrer Daten jederzeit widersprechen. Das Datenhandling bei Sack Fachmedien erklären wir Ihnen in unserer Datenschutzerklärung.