AI Adoption Roadmap

Before You Add AI: A Decision Framework

Not every problem warrants an AI-based solution. The decision tree below is a gate, not a funnel. Work through each question in order. If you can resolve the need at an earlier step, stop there.

If steps 1-3 were skipped, step 4 is not available. An AI solution applied to a process that could be simplified, handled by existing capabilities, or replaced by a deterministic component is complexity in place of clarity.

The Key Insight

The sequence matters: remove friction and add safety before you accelerate. AI amplifies whatever system it is applied to - strong process gets faster, broken process gets more broken, faster.

The Progression

Quality Tools, Clarify Work, Harden Guardrails, Remove Friction, then Accelerate with AI.

Quality Tools

Brownfield phase: Assess

Before using AI for anything, choose models and tools that minimize hallucination and rework. Not all AI tools are equal. A model that generates plausible-looking but incorrect code creates more work than it saves.

What to do:

• Choose based on accuracy, not speed. A tool with a 20% error rate carries a hidden rework tax on every use. If rework exceeds 20% of generated output, the tool is a net negative.
• Use models with strong reasoning capabilities for code generation. Smaller, faster models are appropriate for autocomplete and suggestions, not for generating business logic.
• Establish a baseline: measure how much rework AI-generated code requires before and after changing tools.

What this enables: AI tooling that generates correct output more often than not. Subsequent steps build on working code rather than compensating for broken code.

Clarify Work

Brownfield phase: Assess / Foundations

Use AI to improve requirements before code is written, not to write code from vague requirements. Ambiguous requirements are the single largest source of defects (see Systemic Defect Fixes), and AI can detect ambiguity faster than manual review.

What to do:

• Use AI to review tickets, user stories, and acceptance criteria before development begins. Prompt it to identify gaps, contradictions, untestable statements, and missing edge cases.
• Use AI to generate test scenarios from requirements. If the AI cannot generate clear test cases, the requirements are not clear enough for a human either.
• Use AI to analyze support tickets and incident reports for patterns that should inform the backlog.

What this enables: Higher-quality inputs to the development process. Developers (human or AI) start with clear, testable specifications rather than ambiguous descriptions that produce ambiguous code. The four prompting disciplines describe the skill progression that makes this work at scale.

Harden Guardrails

Brownfield phase: Foundations / Pipeline

Before accelerating code generation, strengthen the safety net that catches mistakes. This means both product guardrails (does the code work?) and development guardrails (is the code maintainable?).

Product and operational guardrails:

• Automated test suites with meaningful coverage of critical paths
• Deterministic CD pipelines that run on every commit
• Deployment validation (smoke tests, health checks, canary analysis)

Development guardrails:

• Code style enforcement (linters, formatters) that runs automatically
• Architecture rules (dependency constraints, module boundaries) enforced in the pipeline
• Security scanning (SAST, dependency vulnerability checks) on every commit

What to do:

• Audit your current guardrails. For each one, ask: “If AI generated code that violated this, would our pipeline catch it?” If the answer is no, fix the guardrail before expanding AI use.
• Add contract tests at service boundaries. AI-generated code is particularly prone to breaking implicit contracts between services.
• Ensure test suites run in under ten minutes. Slow tests create pressure to skip them, which is dangerous when code is generated faster.

What this enables: A safety net that catches mistakes regardless of who (or what) made them. The pipeline becomes the authority on code quality, not human reviewers. See Pipeline Enforcement and Expert Agents for how these guardrails extend to ACD.

Reduce Delivery Friction

Brownfield phase: Pipeline / Optimize

Remove the manual steps, slow processes, and fragile environments that limit how fast you can safely deliver. These bottlenecks exist in every brownfield system and they become acute when AI accelerates the code generation phase.

What to do:

• Remove manual approval gates that add wait time without adding safety (see Replacing Manual Validations).
• Fix fragile test and staging environments that cause intermittent failures.
• Shorten branch lifetimes. If branches live longer than a day, integration pain will increase as AI accelerates code generation.
• Automate deployment. If deploying requires a runbook or a specific person, it is a bottleneck that will be exposed when code moves faster.

What this enables: A delivery pipeline where the time from “code complete” to “running in production” is measured in minutes, not days. AI-generated code flows through the same pipeline as human-generated code with the same safety guarantees.

Accelerate with AI

Brownfield phase: Optimize / Continuous Deployment

Now - and only now - expand AI use to code generation, refactoring, and autonomous contributions. The guardrails are in place. The pipeline is fast. Requirements are clear. The outcome of every change is deterministic regardless of whether a human or an AI wrote it.

What to do:

• Use AI for code generation with the specification-first workflow described in the ACD workflow. Define test scenarios first, let AI generate the test code (validated for behavior focus and spec fidelity), then let AI generate the implementation.
• Use AI for refactoring: extracting interfaces, reducing complexity, improving test coverage. These are high-value, low-risk tasks where AI excels. Well-structured, well-named code also reduces the token cost of every subsequent AI interaction - see Tokenomics: Code Quality as a Token Cost Driver.
• Use AI to analyze incidents and suggest fixes, with the same pipeline validation applied to any change.

What this enables: AI-accelerated development where the speed increase translates to faster delivery, not faster defect generation. The pipeline enforces the same quality bar regardless of the author. See Pitfalls and Metrics for what to watch for and how to measure progress.

Mapping to Brownfield Phases

Related Content

• Brownfield CD Overview - the phased migration approach this roadmap parallels
• Replacing Manual Validations - the core mechanical cycle for Reduce Delivery Friction
• Systemic Defect Fixes - catalog of defect causes that AI can help detect during Clarify Work
• ACD - the destination for teams completing this roadmap
• Anti-Patterns - problems that Harden Guardrails and Reduce Delivery Friction are designed to eliminate
• Agent Delivery Contract - the artifacts that Accelerate with AI’s specification-first workflow requires
• Pipeline Enforcement and Expert Agents - how the pipeline enforces the guardrails from Harden Guardrails and Reduce Delivery Friction
• Pitfalls and Metrics - common failures when steps are skipped, and how to measure progress
• Tokenomics - how code quality drives token cost, and how to architect agents and workflows to minimize unnecessary consumption
• The Four Prompting Disciplines - the skill layers developers need as they progress through the adoption roadmap

Content contributed by Bryan Finster.