Chapter 1: The AI-Powered DevOps Engineer¶
Foundations of Effective AI Usage โ and the Road to Software Orchestration¶
1. The Problem This Book Addresses¶
Ask an AI assistant for infrastructure code and it answers in seconds. The answer looks complete. Then you read it, and spend the rest of the day fixing what it missed.
Nothing in the answer is obviously wrong. It parses. It applies. It looks like the examples already in your repository. It fails in the way that is hardest to catch: it answers the question you typed, not the question you meant. The constraint you thought was obvious is missing. The error case you would have handled is not handled. Both needed a decision from you. The assistant chose, and did not say so.
The AI model is not what decides this. A stronger model writes a better answer to the same question, and the same constraint is still missing. Three things decide whether the answer is usable: what the request required, what the system allows, and what will check the result. The model is not one of the three.
Two engineers, the same AI assistant, the same request. One has something shippable by lunch. The other spends the afternoon repairing what came back. One of them had already written down what the system requires โ the boundaries, the conventions, the checks โ so the assistant could read it. The other kept it in their head, one conversation at a time.
๐ฏ What You'll Learn¶
- Why generated code looks right and is not
- The three structures that decide whether the output is usable โ prompt, engineering, workflow
- What each structure controls, and what its absence looks like
- The shift from writing every change to directing the work that produces it
The DevOps Engineer's Reality¶
| Scenario | Your manager requests a VPC with three subnets, NAT gateways, and route tables by noon. |
|---|---|
| Unstructured Approach | You prompt: "Write Infrastructure as Code for a VPC." |
| The Result | You get code in 30 seconds. Thirty minutes later you are fixing what it assumed: a firewall open to the world, a route that only works in one zone, a subnet range hardcoded. |
| The Cost | Your 10:00 AM task becomes a 4:00 PM incident. |
Why this happens: the request described the task and not the constraints. Nothing in it said who may reach what, which failure it had to survive, or what would count as finished โ so the answer chose defaults, and did not mention them. Written down once, in the repository, those constraints answer every later request the same way.
The AI-DevOps Reality Gap¶
This is a pattern, not a one-off error, and the gap between expectation and reality is consistent enough to be predictable. What people expect is work that fits the system โ precise, aligned with the architecture, safe by default, maintainable by someone else. What arrives is work that fits the sentence they typed: vague where the request was vague, inconsistent with conventions it was never shown, and carrying the defaults of the example it learned from.
The difference is not the model's ability. It is the absence of the context a colleague would have supplied without being asked.
The Core Question:
"How do I integrate AI into my workflow to accelerate delivery without sacrificing reliability, security, or maintainability?"
The Cost of Unstructured AI¶
Structureless AI use does not merely fail to help. It adds work that is harder to see than the work it removed, because the failure arrives later and somewhere else.
Security gaps appear where the request was silent. An instruction to "add a database" that does not say who may reach it produces a database, a network rule, and a decision nobody made.
Costs arrive after the fact. Token spend is the smaller half. The larger half is the shape an unreviewed answer chose: capacity sized for the example, storage that is never cleaned up, a managed service per component because the sample had one.
Incidents are the third bill. Output deployed without a gate is a change nobody verified. It reaches production at the speed it was generated, which is a new property in delivery: the fastest path is also the least reviewed.
Debt accumulates quietly. Generated code that conflicts with the repository's conventions is debt from the first commit. It is not wrong, so nobody files it; it is different, so every later change pays for it.
None of this is inevitable. Each failure is the absence of a specific structure, and structures are things teams already know how to build.
Three Structures That Control Quality¶
Every failure above shares a single root cause: AI was used without structure. This book is built on the premise that three specific structures determine whether AI accelerates or harms your infrastructure.
| Structure | What It Controls | What Happens If Missing |
|---|---|---|
| Prompt Structure | The specificity and constraints of the request. | Vague output, endless iteration, missing constraints. |
| Engineering Structure | How the code fits the existing system architecture. | Architecture drift, inconsistent patterns, technical debt. |
| Workflow Structure | How the team enforces rules and validates output. | Manual inconsistency, weak auditability, knowledge silos. |
Miss one and the other two cannot compensate. A perfect prompt cannot make output fit an architecture nobody wrote down. A perfect architecture cannot verify output no gate inspects.
This book shows you how to build all three, starting with the repository. A structure that lives only in a prompt, or in a tool's memory, vanishes when the session ends. A structure written into a repository is versioned, reviewed and inherited. The repository is the one layer of software development that predates AI and will outlast every AI tool.
The Value Proposition¶
By applying the methods in this book, you will shift your workflow:
| The habit | The replacement |
|---|---|
| Write a prompt and hope | Write the constraints down once, then prompt against them |
| Review whatever came back | Review against a contract that already says what "right" means |
| Fix the output | Fix the structure that produced it, and watch the output change |
| Wonder whether AI is helping | Measure it: rework, delivery time, incidents |
You do not need to be an AI expert. You need to be willing to move the knowledge out of your head and into the repository, where the tool can read it. The three structures do not build themselves. Someone must define them, own them, and direct the AI within them. That person is you. This book calls that way of working orchestration: directing the work rather than doing all of it manually.
2. Your Role as Orchestrator¶
The word is chosen for what it excludes. An orchestrator does not play every instrument, and does not hand the score to the musicians and leave. They decide what is played, in what order, and what counts as finished.
The Role Evolution: From Pipeline to Product to Orchestration¶
The industry is already living this progression. The role this book teaches is the next step in a natural evolution:
| Role | Focus | Primary Artefact |
|---|---|---|
| DevOps Engineer | The pipeline โ delivery speed, CI/CD, environments. | A pipeline that ships code reliably. |
| Platform Engineer | The product โ internal developer platform, self-service, abstracted complexity. | A platform developers build upon without reinventing the wheel. |
| Software Orchestrator | The cognitive architecture โ the prompt, engineering, and workflow structures that allow AI to operate safely. | A decision framework that outlasts any specific tool. |
Each step raises the ceiling on what one engineer can direct. The DevOps engineer automated the path to production; the platform engineer productized the infrastructure underneath it; the Software Orchestrator designs the layer above both โ the structures that direct AI while it executes the work. Orchestration is a promotion in what you design: not the pipeline, not the platform, but the framework that directs them both.
The AI Role Spectrum¶
You retain ownership of intent, architecture, risk, and outcomes. AI handles drafting, repetition, and pattern application.
graph TB
subgraph You["You own"]
A[Problem definition]
B[Architecture and design]
H[Code review and hardening]
C[Approval and deployment]
end
subgraph AI["AI assists"]
D[Prompt refinement, gap analysis]
E[Pattern suggestions, trade-offs]
F[Draft generation, boilerplate]
G[Static analysis, test generation]
end
A --> D
B --> E
H --> F
C --> G
style You fill:#e1f5fe
style AI fill:#f3e5f5
The principle: AI augments human expertise; it does not replace critical thinking, risk assessment, or engineering judgment.
What this means in practice:
| You own | AI assists |
|---|---|
| Problem definition & requirements | Prompt refinement, gap analysis |
| System architecture & design | Pattern suggestions, trade-off analysis |
| Code review, validation & hardening | Draft generation, boilerplate |
| Final approval & deployment decisions | Static analysis, test generation |
The Boundaries You Hold¶
Delegation without boundaries is abdication. The moment AI drafts, reviews, and decides for you, the Orchestrator becomes a passive tool operator. These boundaries prevent that drift:
| The Boundary | Why It Matters |
|---|---|
| AI never stages, commits, or pushes | The ship flow is the Orchestrator's. The AI drafts and edits, then reports changes ready for review (git status / git diff) and stops โ even when a task says "proceed". |
| Review before anything ships | Treat AI output like a junior engineer's PR โ review for logic, security, and maintainability. |
| The repository is the source of truth | Standards and conventions live in version-controlled docs. AI reads them; it does not own them. |
| Validation is automated, not assumed | Quality gates run on every change. AI generates; the repository verifies. |
| Costs are governed like infrastructure | Meter token usage; route each task to the model that fits the requirement. |
The Skill That Outlasts Every Model¶
As AI handles more mechanical work, your expertise redirects. You shift from writing every resource block to designing the structures the tool works within: architecture boundaries, prompt patterns, and validation gates. That design layer outlives every model and every tool.
Core Principles of the Orchestrator¶
Everything in this section distills into one identity: you are the constant; tools are the variables.
Orchestration is not about mastering tools. It is about directing them.
A "tool operator" learns one tool deeply and is locked into its lifecycle. A Software Orchestrator learns a decision framework and applies it across any tool. An orchestrator operates on seven principles:
- Tools are transient. The "best" tool changes constantly. Never bind your identity to one.
- Foundations are permanent. The principles of structure, clarity, and process outlast any specific tool.
- Tool selection is based on fitness for purpose. Not loyalty, not hype, but what fits the task.
- The repository is the source of truth. The tool reads it; the tool does not own it. Your structures persist there.
- We build software products, not tool portfolios. The goal is good software; the tool is just the vehicle.
- The role is Orchestrator. Directing the right tool, at the right time, for the right purpose.
- The self-improving repository is the goal. Structure is persisted, built on and improved โ guided by principles rather than reinvented when a tool changes.
| Tool operator | Orchestrator |
|---|---|
| "Which AI tool is best?" | "Which tool fits this task?" |
| Expert in one tool's keystrokes | Expert in the decision framework |
| Structure lives inside the tool | Structure lives in the repository |
| Locked into a tool's lifecycle | Migrates without losing structure |
| Builds a tool portfolio | Builds software products |
| Rides each tool's lifecycle | Owns a decision framework; tools are interchangeable |
| Value is measured in tool mastery | Value is measured in the software products built |
Before we design the structures this framework points to, we need to understand the thing we are directing: how does AI actually process information?
3. The Mental Model: How AI Thinks¶
Two questions get mixed up here, and they have different answers. What kind of system is the assistant? And what should a request contain? The first decides what you can delegate. The second is what you actually type.
Two Kinds of System¶
A rule engine and a language model are different machines. A rule engine applies logic someone wrote down. A language model predicts what comes next from patterns in its training, which is why it handles requests no one wrote a rule for โ and why it can answer a question nobody asked.
| Rule-based (symbolic) | Learned (data-driven) | |
|---|---|---|
| How it decides | applies rules someone wrote | predicts from patterns in examples |
| Strength | deterministic, auditable, repeatable | handles what nobody anticipated |
| Weakness | fails on anything unanticipated | produces confident output with no guarantee |
| Who supplies the logic | you do, explicitly | the model does, implicitly |
The same two columns as a pipeline โ rule-based on the left, learned on the right, so the table can be read against it:
flowchart LR
subgraph RB["Rule-based ยท symbolic"]
direction TB
RB1["Rules written by you"] --> RB2["Conclusions"]
RB2 --> RB3["Deterministic ยท auditable ยท repeatable"]
end
subgraph LD["Learned ยท data-driven"]
direction TB
LD1["Patterns in examples"] --> LD2["Predictions"]
LD2 --> LD3["Flexible ยท handles the unanticipated<br/>no guarantee"]
end
RB ~~~ LD
Neither wins. A production system uses both: the model drafts, and deterministic parts around it decide whether the draft is allowed โ a schema it must satisfy, a policy check, the tests.
The rules did not disappear when models arrived. They moved to the edges of the work, where they can be checked: a schema the draft must satisfy, a policy that forbids a shape, a test that has to pass.
Two Kinds of Instruction¶
Inside one request, the same division appears again, and this is where the confusion usually starts.
- Constraints you state behave like rules: must, never, only, unless. They are yours, and you can check whether they were followed.
- Freedom you grant is where the model decides: the loop, the naming, the shape of the diff, the choice between two equivalent approaches.
The two are not the same thing as the two system types โ that is the sentence this section exists to make clear. Writing constraints into a request does not turn a language model into a rule engine. It gives the model rules to obey, and leaves the inference where it belongs.
The rule: state what must be true. Let the model work out how.
The constraints are yours. The implementation is the model's.
| A request that leaves everything open | A request that states the constraints |
|---|---|
| "Write a backup script" | "Write a backup script. Check free space first. Verify the archive before deleting a source. Stop and report on any error." |
| The model invents the safety properties, and you inherit them | The safety properties are yours, and the model writes the code around them |
Matching the Request to the Task¶
The rule is not "be explicit about everything". It is "be explicit about what must not be decided by the model".
| The task | Lean on | What you supply |
|---|---|---|
| Boilerplate and scaffolding | the model | examples, house style, surrounding context |
| Architecture and module design | both | the boundaries, and the patterns already in the repository |
| Security and compliance | the rules | the rules, written as checks a gate can run |
| Debugging an incident | both | your analysis, plus hypotheses worth testing |
Look back at the two kinds of instruction, because they have a consequence the section has not stated yet. A constraint you state exists only in that request. The freedom you grant is bounded only by what the model happens to know. And the checks that decide whether the draft is acceptable exist only if someone wrote them down.
Three places, then, where a decision can be made or lost: what the request requires, what the code must fit, and what verifies the result. Leave any of the three to the next conversation and it starts from zero โ which is why the same request produces a different quality of answer on a different day, from the same model.
Give each of those three places a durable home and the answer stops depending on the day. The remainder of this chapter names the three structures, says what each one controls, and shows where they live so that a change of tool does not take them with it.
4. The Three Structures That Control Quality¶
You now have the mindset (Section 2) and the mental model (Section 3). This section turns that observation into a system you can recognise, name and build.
4.1 The Construction Site Analogy¶
Think of AI as a construction crew.
| Structure | Vague Approach | Structured Approach |
|---|---|---|
| Prompt Structure (The Blueprints) | "Build a house" | "A 3-bedroom, 2-bathroom house with a garage and solar panels" |
| Engineering Structure (The Building Code) | "Build it however" | "Must meet fire codes, earthquake standards, and zoning laws" |
| Workflow Structure (The Site Manager) | "Trust the crew" | "Every wall is inspected, every permit is checked" |
The reality: Most teams have blueprints (prompts). Few have building codes (engineering structure) or site managers (workflow structure).
4.2 The Three Structures Visualized¶
graph TB
PS["Prompt Structure<br>Generation Quality<br>'What must be true?'"]
ES["Engineering Structure<br>System Quality<br>'How must it fit?'"]
WS["Workflow Structure<br>Team Consistency<br>'How do we enforce it?'"]
O["Output that is:<br>correct ยท consistent<br>maintainable ยท auditable"]
PS --> O
ES --> O
WS --> O
style PS fill:#e3f2fd,color:#0d47a1
style ES fill:#f3e5f5,color:#7b1fa2
style WS fill:#fff3e0,color:#e65100
style O fill:#e8f5e9,color:#1b5e20
4.3 Prompt Structure¶
What it is: How you communicate your requirements to AI โ the blueprint.
What it controls: Generation quality, correctness, and completeness.
Key elements: A clear task definition; symbolic constraints (rules that MUST be followed); data-driven guidance (patterns to follow); context (your specific situation); and output criteria. Later chapters combine these elements into reusable templates for each task family.
But a great prompt still cannot force output to fit your architecture. That is the job of the second structure.
4.4 Engineering Structure¶
What it is: The architectural framework that AI-generated infrastructure code must fit into.
What it controls: System quality, maintainability, and architectural coherence.
The key principle โ design before generate:
Never ask AI to generate infrastructure before you have defined the structure it must fit.
| The Wrong Way | The Right Way |
|---|---|
| 1. Ask AI to generate | 1. Design the structure first |
| 2. AI generates whatever it likes | 2. Document the structure as rules |
| 3. Code works today | 3. Ask AI to generate code that fits |
| 4. Technical debt accumulates | 4. Validate it follows the rules |
The engineering structure contract. Before generating anything, define the shape your code must take: module and component boundaries, dependency rules, state and configuration handling, naming conventions, validation gates, and error-handling expectations. This contract is the blueprint that tells AI how to generate code that fits your architecture.
Key Insight โ Platform engineering is the foundation. Great AI orchestration is built on great platform engineering: the discipline of turning infrastructure complexity into clear boundaries and paved roads. If your infrastructure is a tangle of one-off scripts and half-documented conventions, AI will generate more tangle, faster. But if you have already drawn the boundaries and abstracted the complexity, you have built the perfect engineering structure. AI thrives inside clear, platform-level constraints.
4.5 Workflow Structure¶
What it is: How your team makes the first two structures repeatable through automation and process.
What it controls: Team consistency, auditability, and automation.
Key elements: Validation gates, task automation, shared context, and review checklists.
Why it matters: Without workflow structure, quality depends on who remembered which rules that day. Workflow structure makes quality automatic and team-wide.
4.6 How the Three Structures Work Together¶
flowchart TD
Start[Start with a Task] --> P[Prompt Structure<br>Define constraints]
P --> E[Engineering Structure<br>Define architecture]
E --> G[Generate AI Output]
G --> W[Workflow Structure<br>Validate & enforce]
W --> Q{Passes<br>Validation?}
Q -->|Yes| Done[โ
Production-Ready Output]
Q -->|No| F[AI Fixes Issues]
F --> W
style Start fill:#e1f5fe
style P fill:#e3f2fd
style E fill:#f3e5f5
style W fill:#fff3e0
style Done fill:#e8f5e9
style F fill:#ffebee
This loop is the core of the book. Prompt structure defines what must be true, engineering structure defines how it must fit, and workflow structure verifies both, then feeds the results back in.
4.7 Where the Structures Live: The Repository¶
Where does this loop live? The answer is not a new tool, a new platform, or an AI innovation. It is the oldest, most dependable layer of software development we already have: the repository.
A repository already gives every team four critical properties: 1. Persistence: Work survives the machine it was written on. 2. Versioning: Every change is tracked, allowing rollback and audit. 3. Sharing: The whole team builds on one source of truth. 4. Accumulation: Today's work is tomorrow's starting point.
Those four properties are exactly what structured AI usage needs.
The core principle: The three structures do not live in your AI tool; they live in your repository. The tool reads them; the tool does not own them.
Be precise about the terminology. The three structures are the prompt, the engineering, and the workflow. The repository is not a fourth structure; it is the home of all three.
Governance documentation โ the universal pattern. High-performing teams codify how they work in three types of tool-agnostic documents:
| Document Type | Purpose |
|---|---|
| The Law | The non-negotiable rules โ what MUST be true, what MUST NOT happen; the symbolic constraints AI is never allowed to break. |
| The Map | Background and context โ the architectural boundaries and business context the AI reasons over. |
| The Playbook | Executable procedures โ validation gates, quality checks, and the repeatable tasks that enforce the first two. |
These documents are tool-agnostic. Any AI tool can read them. The tool is a reader of structure, not the owner of it.
| Structure | Encoded as | What It Represents |
|---|---|---|
| Prompt Structure | The Law | The symbolic rules that constrain every request. |
| Engineering Structure | The Map | The architectural boundaries and business context the output must fit. |
| Workflow Structure | The Playbook | The automated enforcement and procedural tasks that make the first two hold. |
The permanence principle:
Structure lives in the repo, not in the tool.
When you change AI tools, your prompt templates, engineering decisions, and workflow enforcement all come with you. You only lose the tool-specific shortcuts, never the structure.
4.8 Two Patterns That Make the Repository a Living System¶
The self-modifying runtime. The repository holds the automation logic that can improve its own contents. AI operates inside this environment, guided by the repository's own rules, and its improvements are validated before they are applied. The heartbeat: Propose โ Validate โ Apply โ Repeat.
| Tool-Centric Runtime | Repository-Centric Runtime |
|---|---|
| AI tool remembers conversations | Repository remembers state through version control |
| Tool's context is temporary | Repository's context is permanent |
| Switching tools loses context | Repository context survives migrations |
| Tool defines the workflow | Repository defines the workflow through automation |
The command surface. The commands you use to interact with the repository form a stable, predictable interface โ one surface a person types into and an agent calls, whose exit codes say success, failure, or the input refused by name. The underlying tools can change; the verbs you use stay the same.
| Command Category | Purpose | Stability |
|---|---|---|
| Quality commands | Check, validate, lint | Stable interface; implementation may vary |
| Improvement commands | Generate, enhance, refactor | Stable interface; AI tool may vary |
| Evolution commands | Validate โ Fix โ Re-validate | Stable workflow; scripts may vary |
The contract is implemented by two surfaces: one for the repository in front of you โ its build, its checks, its deploy โ and one for the work that crosses repositories, such as committing, releasing and syncing. Chapter 2 ยง9 names both, and says which verb belongs on which.
Stable interface, pluggable implementation. You can switch assistants or task runners without relearning how to work, and documentation stays valid because it refers to the commands, not the tools.
4.9 What "the Outcome" Means: Ten Abilities (NFRs)¶
"The outcome" is not a feeling, and it is not a benchmark score. It is a set of properties you can name, attribute to the structure that controls them, and eventually evidence. In engineering, we call these Non-Functional Requirements (NFRs), or the "-bilities". Naming them keeps this book honest: a promise you cannot check is marketing.
| Family | Ability | What it means | Controlled by |
|---|---|---|---|
| It is right, and it shows its work | Correct | It does what it claims โ completely, including edge cases. | Engineering |
| Verifiable | Every claim that "it works" resolves to a check you can run, and that can fail. | Workflow | |
| Maintainable | Someone who did not write it can change it correctly and verify the change. | Engineering | |
| Auditable | Every change has a provenance and a signer, human or agent. | Workflow | |
| Secure & private | It resists misuse, and personal data is processed lawfully, minimally, and on purpose. | Engineering + Workflow | |
| It works for the people who use and run it | Usable | The surfaces (CLI, API, console, errors, docs) work for their intended users. | Workflow |
| Reliable & available | Correct and consistent over time, with a rehearsed rollback path. | Engineering | |
| Operable & diagnosable | The artefact reveals its own state: you can see what it is doing, understand why, and restore it quickly. | Engineering + Workflow | |
| It grows, and you can leave | Scalable & affordable | Capacity and organization grow without a rewrite, at a known cost. | Engineering |
| Portable & interoperable | It coexists with other systems and can be moved or replaced without a rewrite. | Engineering + Workflow |
Read this table like a contract: - An ability without evidence is a claim, not a property. Where this book cannot yet show the evidence, it states so. - An ability you cannot attribute to a structure is a wish. If no structure controls it, no amount of prompting will produce it.
These ten abilities are what the rest of the book is for. Part One names them; the practice parts produce them on real work and prove them.
The capstone: from driver to outcome.
The three structures answer how AI work stays correct, but they are not the point of the repository by themselves. The point is what they make possible.
| Link in the chain | What it is | Where this book builds it |
|---|---|---|
| The driver | the purpose the repository exists to serve โ why any of this work matters | named in Chapter 2, revisited as the capstone of every chapter |
| The delivery plan | the inventory of work that turns the driver into reality, each item with its own lifecycle | Chapter 2 (the feature catalogue) |
| The three structures | how AI is governed while doing that work โ this chapter's subject | Part One (the concept) ยท Part Two (in depth) |
| The outcome | whether the driver holds in production โ the abilities named in ยง4.9, each with its evidence | Part One (named) ยท Part Two and Three (evidenced) |
A structure that governs nothing real is a hobby. The repository exists to move the driver to the outcome, and the three structures are how AI is kept correct along the way.
5. How This Book Is Organized¶
This chapter is the conceptual foundation. It deliberately does not teach you how to write prompt templates, run security checks, or pick a model. Those topics belong where they are applied. The book is organized in four parts:
| Part | What It Delivers |
|---|---|
| Part One โ Foundations | The argument (this chapter), the repository that holds it (Chapter 2), and the abilities the whole method must deliver (ยง4.9). |
| Part Two โ The Instrument | What the agent works with, in the order it meets it: the language that names things, the command surface that acts, the context it reads and what that costs, the session it cannot remember, the procedure that sequences a change, the boundary where its authority ends, and the log that proves it all happened |
| Part Three โ The Boundary | What you do not own โ governed from inside the repository: the build-or-buy-or-assemble decision and its exit plan; upstream products as dependencies; the provider seam; contracts that keep services independent; sovereignty, portability and the exit drill |
| Part Four โ The Guarantees | What one system must be able to prove before it is asked to scale: show its state (evidence), survive its loss (recoverability), refuse a bad change (the gate) |
| Part Five โ The Delivery System | The mechanism at portfolio scale: version control as the source of truth, the control plane as a product, versioning and release, deploy and the way back, governance, the agent plane, operations, the fleet, and measurement |
How to read this chapter: read it once for the argument. The concepts return throughout the book and are referenced as they are applied.
The promise, stated once. Everything that follows depends on one claim: the three structures โ prompt, engineering and workflow โ live in the repository, not in the tool. If you accept that, the rest of the book is application. If you do not, no amount of better prompting will help, because the thing that keeps AI work correct has nowhere to live.
The road ahead. The engineer who directs this work is a Software Orchestrator, and the advantage comes from three structures โ prompt, engineering, and workflow โ held in the repository, above any single tool. Chapter 2 makes it real. It shows you how to build the self-improving repository that holds those structures, and everything after it builds on that foundation.
From argument to practice โ Chapter 2 builds the foundation.
Part of: The DevOps Engineer's Guide to Effective AI Usage โ and Becoming a Software Orchestrator