Have you ever wondered "AI tools increase productivity, but where should our team start"? Converting an existing legacy project into an AI transformation (AX) is a challenge many teams face.
For example, what if a development cycle that used to take 2–3 days from specification to testing could be completed in 2–3 hours with an automated AI process? If multiple cycles can be completed in a single day, this change would create a significant long-term competitive advantage for the team.
The table below summarizes the expected changes after AX (this represents target levels that teams completing the four-step AX roadmap described in this article might achieve; actual results vary with team size, domain complexity, and adoption speed)
| Item | After conversion to an AI-driven project |
|---|---|
| Pull request (PR) cycle | Average 2–4 hours |
| Test coverage | 80% or higher (automatically maintained) |
| Code review | Automated |
| Daily merges | 20–40 across the team |
However, simply adopting AI tools without a clear direction rarely leads to the productivity gains above. Many teams encounter barriers during AI adoption and without a clear goal it is hard to overcome them.
- Skill imbalance: Differences in team members' proficiency with AI tools reduce collaboration efficiency
- Lack of context: Poor documentation prevents AI from receiving proper project background knowledge
- Reliability issues: Insufficient test coverage makes deployments of AI-generated code unstable
Our organization is also working on AX at an organizational level while considering how to overcome these barriers. We started with basic steps such as classifying information levels and migrating to secure infrastructure, then standardized AI guidelines and integrated with continuous integration/continuous delivery (CI/CD) as we iterated.
This article is an AX execution roadmap compiled with the question "how can team-wide AI use avoid fragmentation and become a stable part of the team's systems and culture to improve productivity"? It explains the four-step AX roadmap for converting legacy projects to AI-driven projects step by step, and reviews concrete tasks and benefits for each stage.
What is an AI-driven project?
An AI-driven project goes beyond using AI for simple assistance and integrates AI deeply into the whole development cycle. Using AI coding agents such as Claude Code or Codex CLI, you can make AI actively handle steps from spec writing to code generation, testing, review, and merge while humans focus on judgment and direction. What makes this different from simply using AI tools is that the entire team workflow is designed around AI.
Core methodology of AI-driven projects: Spec-driven development
The core of this approach is spec-driven development (SDD). SDD is one of the most notable methodologies in AI coding environments. Unlike code-first approaches or test-driven development (TDD), SDD defines requirements and specs first in a clear structure, and AI generates and verifies code based on those specs. With clear specs, AI generates, reviews, and tests code to complete the development. AI models are strong at pattern completion but limited at fully capturing abstract intent. SDD compensates for those limits and produces systematic results optimized for AI workflows.
AX four-step roadmap
The core goals and effects of each AX stage are as follows.
| Stage name | Core goal | Effect |
|---|---|---|
| Stage 1: AI-ready | Remove security risks and build an environment where AI can be used safely | Create a foundation that lets the team use AI with confidence |
| Stage 2: AI-assist | Standardize usage guidelines and introduce CI/CD-integrated assistant processes | Visible improvement in team-wide code quality and speed |
| Stage 3: AI-development | Automate feature implementation and test generation based on SDD | Escape repetitive work and achieve exponential productivity gains |
| Stage 4: AI-review | Complete automation where AI agents lead review and merge | Achieve a true AI-driven development culture with minimal human intervention |
Each stage has independent value, and it is not necessary to complete all four stages to get meaningful benefits. Set target stages according to your team's situation, risk tolerance, and domain complexity, and achieving the core goals of a chosen stage will deliver the corresponding productivity improvements.
Stage 1: AI-ready — Establish security and compliance foundations
The first step in adopting AI is to eliminate data leakage risks and establish reliable guidelines. Although many enterprise AI services guarantee against model retraining, a data leak could still be catastrophic. Define the allowed scope of AI according to your compliance standards and set up processes to prevent AI from accessing sensitive data in the first place.
Key tasks for stage 1
1. Strengthen sensitive information management
Go beyond removing secrets from code and set up systems to prevent sensitive information from being exposed throughout the development lifecycle.
- Eliminate hardcoding: Remove hardcoded values in code such as API keys, database passwords, and internal IP addresses
- Adopt dynamic injection: Use a secrets manager service and migrate to environments that inject values dynamically at application runtime
2. Protect personal data and privacy
In addition to confidential information, strictly prevent personally identifiable information (PII) from being sent to AI models.
- Deidentify data: Mask or tokenize PII such as names, emails, and phone numbers before sending to AI to prevent privacy breaches
3. Protect business-critical assets
Protect intellectual property that determines competitive advantage, such as proprietary algorithms and complex architectures.
- Access control: Manage core logic that AI could analyze or imitate in separate private repositories or restrict AI access to those areas so they are operated strategically in isolation
Strategic tips for quick stage 1 adoption
To secure a safe environment for AI, review the checklist above and migrate to a secure environment. Because migrating to a secure environment often takes time, it can be hard to experience short-term productivity gains from AI, which may reduce motivation. We therefore recommend a phased adoption strategy.
- Define essential requirements first: Select and immediately apply the most critical compliance requirements such as encrypting sensitive information
- Use isolation techniques: Limit AI activity with sandboxing features like system prompt settings or network isolation so sensitive data is not exposed to AI
- Use a parallel verification process: When using isolation techniques, also run verification processes that block file system and network access to ensure sensitive data is not exposed
Expected benefits from stage 1
- Security risks reduced: Create a safe work environment where code context can be provided to AI with confidence
- Personal productivity increase: Safely using AI coding agents improves debugging, documentation, and repetitive code writing velocity
- Team capability internalized: As each team member gains safe AI experience, momentum builds for progressing to stage 2 (AI-assist)
Stage 2: AI-assist — Standardize project usage
This stage is for teams where members use AI but approaches and skill levels vary, resulting in inconsistent outputs that have not yet translated to team-wide productivity gains.
At this stage, bring individual AI usage into the team workflow. Create and maintain a project-level guideline document for AI, build and manage a skills set, and introduce automation processes integrated with CI/CD so repetitive tasks like code review are handled consistently across the team. This prevents AI usage from becoming fragmented and standardizes it across the team.
Note that at this stage AI does not write code directly. AI assists by reviewing and supporting human-written code.
Key tasks for stage 2
1. Manage AI guidelines
Create a dedicated rules document in the repository root so AI understands project context. Write project overviews, coding conventions, architecture principles, and a domain glossary in a format AI can read.
2. Adopt standard skills or related tools
Build a common AI skills set so the whole team can achieve consistent output quality.
- Adopt standard prompts and skills: Create or adopt team common skills for code review, brainstorming, and planning
- For example, superpowers is an open source skills plugin that works with AI coding agents such as Claude Code. It provides skills for brainstorming, writing plans, and subagent-driven development tailored to each stage of the development cycle
3. Build AI-assisted processes integrated with CI/CD
Automate repetitive review work so people can focus on business logic.
- AI-based automated code review: When a PR is opened, AI performs a first review, checks code style and flags potential bugs or security vulnerabilities, and gives immediate feedback
- Optimize reviewer work: Humans focus on complex business design and policy decisions that AI cannot handle, maximizing review efficiency
Expected benefits from stage 2
Benefits expected when adopting stage 2 include the following.
- Raise baseline AI proficiency: Integrate fragmented AI usage patterns into a team standard workflow to raise organization-wide skill levels
- Streamline code review and collaboration: AI handles repetitive review tasks, reducing reviewer cognitive load and allowing focus on higher-value judgment
- Maintain consistent output quality: Standardizing project rules and skills keeps code quality high regardless of who wrote it
Example KPIs to measure stage 2 adoption
Stage 2 effects can be measured with KPIs such as the following.
- Change in human review comments: Analyze the change in the number of comments left by developers. A decrease indicates AI effectively replaces repetitive feedback and reduces reviewer cognitive load.
- Test coverage and stability: Track test coverage trends across the codebase. Increased coverage indicates active AI-assisted test writing, which improves release reliability and system stability.
Stage 3: AI-development — Development automation
The goal of stage 3 is to build an automated pipeline where specs directly become working code. AI generates working code based on human-defined specs while understanding the domain knowledge and architecture context of the existing codebase.
Stage 3 pipeline overview
This pipeline includes three gates where humans control whether to proceed and set direction: Spec review, implementation plan review (including test plans), and code review. Each gate is an approval point AI must pass before executing the next step. The pipeline from spec input to PR creation with these gates is built as follows.
We will examine the pipeline step by step.
1. Spec definition
Define the initial spec based on existing domain knowledge. Clearly specify requirements, implementation scope, edge cases, and validation criteria. If you adopted superpowers in stage 2, use the brainstorming skill to evolve ideas into clear specs.
After defining the spec, a human reviews and approves it before proceeding (Human Gate 1). At this point you can adjust the implementation scope or add and remove requirements.
2. Planning
Based on the spec, AI automatically creates a concrete implementation plan and test plan. If you have superpowers, use the writing-plans skill so AI produces implementation and test plans.
After planning, humans review and approve the implementation and test plans (Human Gate 2) before code implementation begins.
3. Code implementation
AI implements code based on the execution plan. Independent AI subagents process each task sequentially based on the plan. If you adopted superpowers in stage 2, use the subagent-driven-development skill to proceed from specs and plans to implementation.
When humans perform the final review and approve, the code is merged (Human Gate 3).
Key tasks for stage 3
1. Internalize domain knowledge and inject context
For AI to write code optimized for the project environment, it needs more background than just scanning code. Do the following.
- Document knowledge: Create structured documents that make architecture principles, business logic peculiarities, and system diagrams easy for AI to reference. Convert existing spec documents into a common format so AI can use them.
- Provide context: Set up a project-specific directory or custom skills in AI tools or a retrieval-augmented generation (RAG) system so AI can look up necessary knowledge when needed.
2. Pipeline automation
Automate the flow from spec file creation to PR generation as follows.
- Event triggers: Set up triggers so CI detects new files added to a specific directory (for example, /specs) and runs stage-by-stage tasks (planning then implementation).
- CI configuration: Define tasks for each CI stage using AI tools.
- Explicit approval steps: Place an Approval Step inside the CI pipeline so AI tasks do not proceed without human approval.
Stage 3 adoption tips
Entrusting core logic to AI from the start may produce low-quality output that is not optimized for the project, which can erode trust in AI processes. We recommend progressively expanding the scope entrusted to AI in the following order.
- Test code: Automatic generation of unit and integration tests for existing logic
- Boilerplate: Repetitive CRUD logic and API spec implementations
- Business logic: Core features involving complex domain policies
Expected benefits from stage 3
Benefits expected when adopting stage 3 include the following.
- Exponential productivity gains: A code-as-spec environment where working code is generated from clear specs
- Freedom from repetitive work: Hand off patterned tasks to AI so humans focus on architecture and business decisions
Example KPIs to measure stage 3 adoption
Stage 3 effects can be measured with KPIs such as the following.
- Spec-to-PR time: Measure time from requirement definition to PR creation. Shortening this time indicates the automated workflow is functioning as intended and ideas are turning into code faster
- Daily merge count: Aggregate daily merges across the team from Git history. An increase indicates the automated pipeline from spec to code is improving team productivity
Stage 4: AI-review — review automation
Stage 4 is full automation where AI goes beyond being a coding assistant and leads quality assurance and merge decisions. Developers focus only on what to build, and technical work from implementation to verification is completed through interactions among AI agents.
Automate as much as possible with AI; this is the core of converting to an AI-driven project. Of the three reviews performed in stage 3 (spec review, implementation and verification plan review, and code review), code review takes the most effort because it requires deep domain and architecture understanding. Automating this stage is what enables dramatic productivity gains. When AI fully handles code review, the entire process from spec to deployment becomes automated and the AI-driven project is realized.
Because code review automation means releasing code without human intervention, optimizing for AI trustworthiness and allowing enough time are essential. People may be uncomfortable with code merging without final human approval, but the risk of bugs exists for both humans and AI. Ultimately this is a matter of risk management. To minimize AI review risk, thoroughly examine verification methodologies in the planning stage. After thorough review, build automated processes that fully cover the validation scenarios so human review can be safely replaced.
Stage 4 pipeline overview
The final flow from spec definition to code merge is as follows. The stage 3 pipeline adds "4. AI code review" and "5. Gatekeeper".
We explain the added steps below.
4. AI code review
Based on accumulated domain context and architecture knowledge from stage 1-3, AI performs code review. Using external plugin skills such as superpowers' requesting-code-review can generate detailed review feedback.
AI classifies issues by severity levels to indicate how urgently they should be fixed.
- Critical: Fatal items that must be fixed before release such as bugs, security vulnerabilities, or data integrity defects
- Important: Major items strongly recommended for fix such as performance regressions, architecture violations, or maintainability issues
- Minor: Optional improvements for quality such as code style, naming conventions, and documentation
5. Gatekeeper
The gatekeeper aggregates AI code review results and decides whether to accept the changes and merge the code. Rather than blindly accepting AI review comments, validate technical soundness against existing domain context before making a final decision. Using external plugin skills such as superpowers' receiving-code-review can optimize the feedback acceptance process.
If the severity exceeds a threshold (for example, important or higher), return to the implementation stage to make fixes, and approve the final merge only when all issues are resolved.
Key tasks for stage 4
1. Strengthen verification processes
Build thorough automated verification processes to guarantee final output quality.
- Maintain verification plan consistency: Test final outputs according to the verification methodology approved during stage 3 planning. All new features must pass these tests before merge
- Reinforce regression tests: Create end-to-end test suites for major features to prevent new features from impacting existing systems
- Test design based on documentation: Refine test scenarios using integrated specs and domain knowledge so gaps between implementation and verification are minimized
2. Automate code review and merge pipelines
Replace human code review completely with AI to maximize operational efficiency.
- AI review agents: Dedicated AI trained on project domain context and architecture performs reviews. Each review comment carries a severity level (critical, important, minor) to clarify priorities
- Gatekeeper: The gatekeeper makes the final judgment on the validity of review results. Items requiring action return to development
- Iterative quality improvement: Automate the "fix-re-review-test" loop so final merges are approved only after all defects are resolved
Pipeline hardening
Even in full automation, exceptions such as unintended code changes or persistent verification failures may occur. In these cases humans must intervene to continue code fix, review, and merge cycles; however, intervention should not stop at simple code fixes. Analyze why the pipeline failed and identify context or validation logic the AI missed. Focus on hardening AI review rules and verification pipelines so similar issues do not recur rather than only manually fixing current bottlenecks.
Gradual rollout strategy
Because some projects require very high reliability, there may be resistance to allowing AI to auto-merge. In those cases, introduce partial automation by importance instead of applying it across the codebase, gradually narrowing the review scope.
For example, start by having humans review changes to core business logic while allowing AI to review and auto-merge other changes. As AI review data and trust accumulate, progressively reduce the scope of human reviews.
Final workflow
The final workflow after completing the four-stage roadmap is as follows.
- [Human] Spec definition: Make key decisions on requirements, business goals, interfaces
- [AI] Planning: Create implementation and verification plans by analyzing specs
- [Human] Plan approval: Review and approve AI-proposed plans
- [AI] Code implementation: Write code, run unit tests, and create PRs according to approved plans
- [AI] Code review: Review code and assign severity levels based on domain context
- [AI] Decision on reflection: Determine whether to request fixes or approve based on review comments
- [AI] Code merge: Automatically merge verified code into the codebase
Expected benefits from stage 4
Benefits expected when adopting stage 4 include the following.
- Elimination of development bottlenecks: Automate human-limited review processes to remove cycle slowdowns
- Completion of AI-driven project transformation: Build a model that automates everything from spec to generation, review, and deployment
- Team focus on real problems: Free engineers from routine code review so they can invest resources in complex business logic and architecture improvements
Example KPIs to measure stage 4 adoption
Stage 4 effects can be measured with KPIs such as the following.
- AI auto-merge rate: The proportion of PRs merged by AI without human reviewer intervention. An increase indicates organizational trust in AI review and that the code integration process is entering autonomous operation
- Regression bug rate: Track post-deployment regression bugs from AI-merged code. This KPI judges whether the AI-designed test scenarios and validation logic fully covered implementation outcomes. A low number means the AI-built safety net effectively replaces human intuition
- Review cycle efficiency: Measure the proportion of total time from PR creation to merge spent in review wait time. A decline compared with stage 3 indicates the human reviewer bottleneck has been removed and development productivity is maximized
Conclusion
Because AI is advancing rapidly, new models can render past work obsolete overnight. Therefore, AX should focus on sustainable design that anticipates technological progress rather than simply adopting popular tools. You need discernment to apply to the organization what will persist and what will fade.
The four-step roadmap presented here focuses on the unchanging essentials. No matter how tools evolve, the initial input to software development is always requirements and the final output is software. This is why the roadmap centers SDD as a core principle. Human processes for defining and validating requirements remain essential, and a team that solidifies this structure can adapt to new AI models or agents by swapping core steps without overhauling the entire system.
I hope this roadmap helps teams move beyond merely using AI and lead sustainable productivity improvements by actively leveraging rapid technological advances. Thank you for reading.
