> ## Documentation Index
> Fetch the complete documentation index at: https://lib.findy.co.jp/llms.txt
> Use this file to discover all available pages before exploring further.

# How to drive AI adoption: levels and an improvement cycle

> AI adoption is the work of turning generative AI tools into measurable gains in an engineering organization's productivity. Covers AI utilization levels, staffing, and the visualize–distribute–embed cycle.

## Overview

AI adoption is the work of turning the rollout of generative AI tools into improved developer productivity and product outcomes for an organization. It goes beyond distributing tools and announcing how to use them: it includes measuring the state of the engineering organization and its AI usage, identifying what is missing, and embedding the fixes in the organization as working mechanisms.

This page covers why productivity often does not rise after AI is introduced, the foundation AI usage depends on, "AI utilization levels" as a yardstick for where an organization stands, how to staff the effort, and the cycle that keeps it running.

The individual tools and extensions are explained on their own pages. See [Vibe Coding](https://lib.findy.co.jp/ai/vibe-coding.md) for conversational development with AI, [Agentic Workflow](https://lib.findy.co.jp/ai/agentic-workflow.md) for delegating implementation to AI, and [Plugins](https://lib.findy.co.jp/ai/plugin.md) for distributing skills and other extensions across an organization.

## Why productivity does not rise just by introducing AI

### The gap between perception and actual results

After AI is introduced, developers tend to feel that they write code faster. That feeling does not necessarily translate into more releases or more value delivered. Whether perception and results have diverged has to be checked against measured numbers.

A common pattern is that AI sped up only one step, code generation, and the bottleneck simply moved to another step. For example, if AI output goes to review without the author understanding it, review comments and fix round-trips increase, and the throughput of development as a whole stays the same.

### AI scales both strengths and weaknesses

AI amplifies both the strengths and the weaknesses an organization already has. Using AI without a solid foundation amplifies weaknesses like these:

| Missing foundation | Amplified problem |
| - | - |
| No coding conventions | Generated code varies in style and structure |
| No test code | Correctness cannot be guaranteed, so defects and incidents increase |
| Coarse task granularity | Huge pull requests are mass-produced and review breaks down |

AI follows the existing code and mechanisms, so low-quality code yields generated code of similar quality. AI does not make slow development fast; it makes development that was already fast even faster.

## The foundation for AI usage

Before advancing AI usage, confirm that the basics, which matter regardless of AI, are in place. Build them from the bottom up in the following order, adding each layer only after the one below is solid.

| Order | Layer | Contents |
| - | - | - |
| 1 | Code quality and tests | Consistent conventions, type definitions, sufficient test code |
| 2 | Development culture | Pull request granularity, review culture, the habit of breaking down tasks |
| 3 | Guardrails | Documentation such as READMEs, instruction files and rules for agents, written conventions |
| 4 | Rolling out skills and plugins | Turning proven workflows into skills and distributing them across the organization |

When AI does not produce the output you expect, review this foundation before revisiting how AI is used. The basics come first; AI usage comes after.

## AI utilization levels

AI utilization levels are a three-stage yardstick for what an organization or team entrusts to AI. Use them to identify where you are now and decide what to work on next. The levels are not alternatives to choose from; they are built up step by step on top of the foundation. They are a separate yardstick from the three levels of productivity covered in [Understanding Developer Productivity](https://lib.findy.co.jp/productivity/why-measure.md).

| Level | Goal | Target steps | Role of AI | Role of humans |
| - | - | - | - | - |
| Level 1 | Build fast | Code changes, pull request creation, self-review | Generates code, creates the pull request, and runs the self-review | Steers code generation and judges self-review results |
| Level 2 | Build right | Task breakdown, issue creation, review | Breaks down tasks into structured issues, implements in parallel, extracts review points | Sets the direction of tasks and issues, reviews |
| Level 3 | Build what is needed | Requirements definition, QA | Assesses the current state, structures requirements, supports QA perspectives and execution | Decides what to build, owns final quality assurance |

Levels 1 and 2 concern output (how much and how well you build), while Level 3 concerns outcomes (the value of what you build).

```mermaid theme={null}
flowchart LR
    A[Requirements] --> B[Task breakdown] --> C[Issue creation] --> D[Code changes] --> E[Pull request] --> F[Self-review] --> G[Review] --> H[QA] --> I[Merge] --> J[Release]
    subgraph L3[Level 3: Build what is needed]
      A
      H
    end
    subgraph L2[Level 2: Build right]
      B
      C
      G
    end
    subgraph L1[Level 1: Build fast]
      D
      E
      F
    end
```

### Level 1: Build fast

Level 1 is the stage where an AI agent generates code and pull request creation is automated. [Vibe Coding](https://lib.findy.co.jp/ai/vibe-coding.md) belongs to this level.

At this level, common problems are large individual differences in how well people use AI, and lower pull request quality because AI output is sent to review without being understood. To address them, clarify understanding and responsibility as follows.

* **Humans are responsible for the code AI outputs.** However much is automated, humans own final responsibility for quality and judgment.
* **Split review into self-review and review.** Entrust AI with the self-review that happens before requesting review, and settle checks of the code change itself there. Focus human review on what humans must ultimately judge.
* **Prepare guardrails for AI to reference.** READMEs, instruction files for agents, coding conventions, and commands for routine tasks let AI understand the context and produce output of consistent quality repeatedly.

### Level 2: Build right

Level 2 is the stage where you prepare the procedures to hand to AI and delegate implementation to an [agentic workflow](https://lib.findy.co.jp/ai/agentic-workflow.md). Humans decide the direction of tasks and issues, and AI plans, implements, and verifies its own work.

The problem at this level is that the procedure for realizing requirements is not in a form AI can take. Nobody has decided task granularity or steps, and knowing what to give AI so it works accurately depends on specific individuals. To fix this, put the following three elements in place.

| Element | Contents |
| - | - |
| Task breakdown | Split requirements into units AI can process easily |
| Issue creation | Express the broken-down tasks as structured parent and child issues |
| Redefining code review | Separate the self-review AI handles from the review humans handle |

The quality of AI's output is determined by the quality of the task breakdown, the blueprint you hand it. Moving from Level 1 to Level 2 is also a shift from collaborating with AI to delegating to it.

| Aspect | Collaboration (Level 1) | Delegation (Level 2) |
| - | - | - |
| Relationship | A partner working alongside you | An executor you assign tasks to |
| Role of humans | Operate directly while AI assists | Give goals and constraints, step in only when judgment is needed |
| Unit of delegation | One line to one function | A task, a pull request, or an entire flow |
| Human-to-AI ratio | 1:1 | 1:N (multiple tasks delegated in parallel) |

Once you delegate multiple tasks in parallel, running AI agents side by side in several terminal windows or panes becomes easier than working one task at a time in an IDE. The development environment itself shifts toward one that makes parallel delegation easy.

### Level 3: Build what is needed

Level 3 is the stage where AI support extends beyond engineering into requirements definition and QA, reaching upstream decisions about what to build.

Once development is fast and correct, the bottleneck becomes deciding what to build. This happens when only engineers can investigate whether requirements are feasible, or when initiatives move forward while the concepts of the system and the product stay apart.

The starting point at this level is understanding the current state of both the system and the product. With both measured and retrieved, examine what an initiative will change and how, then run the implement–verify–measure cycle with high reproducibility.

## Staffing AI adoption

### Make it a dedicated role, not a side job

AI adoption stalls when it is combined with day-to-day development work, for three reasons.

* **Volume.** AI tools update almost every week, and part-time effort cannot keep up.
* **Priority.** Evaluation, rollout, and education happen at the same time, and as a side job, daily work wins and adoption gets pushed back.
* **No owner.** When it is unclear who is responsible, internal rollout is delayed and the skills you built eventually stop being used.

So for the same total effort, one dedicated person moves adoption faster than several people each spending a fraction of their time. A dedicated owner who handles information gathering, evaluation, and rollout end to end also makes ownership clear.

### Qualities needed in the person driving adoption

| Quality | Contents |
| - | - |
| Broad knowledge | A broad grasp of development as a whole rather than deep expertise in one area, because adoption touches many areas |
| Enthusiasm for AI | Using AI more than anyone and keeping up with its changes, because the job means working with AI all day |
| Drive | Taking initiative and seeing measures through until they are embedded |
| Influence | Bringing others along and spreading changes company-wide |

Few people meet all of these. Enthusiasm for AI is hard to compensate for with support from others, so the realistic options are to assign an experienced engineer, or to assign an enthusiastic junior engineer and have others support them.

## The AI adoption cycle

AI adoption does not end with a single initiative. Keep running "visualize → distribute → embed" as one cycle.

```mermaid theme={null}
flowchart LR
    V[Visualize<br/>Read the numbers, turn findings into skills] --> D[Distribute<br/>Deliver company-wide via plugins]
    D --> P[Embed<br/>Notifications, meetings, and training]
    P --> V
```

### Visualize

Visualization is essential for running the improvement cycle with high reproducibility. Improvements based on intuition or experience sometimes work, but you cannot explain why they worked, so you cannot repeat them.

When visualizing, read the following two axes side by side. Either one alone cannot trace why results are not appearing.

| Axis | What to look at | What it tells you |
| - | - | - |
| Developer productivity | Pull requests created per person, time from commit to open, time from review to approval, number of comments, Four Keys, and so on | Whether results are changing, and which step is lagging |
| AI usage | Adoption rate, number of sessions, token volume and cost, types and counts of skills, agents, and MCP servers in use | Who uses AI, where, and how, and why results are not appearing |

In the PDCA cycle, both Plan and Check need a step that reads the visualized numbers. How accurately you read them changes both your hypotheses and your evaluations, and determines the hit rate of your improvements. Turn the findings into skills and agents. The productivity metrics themselves (and the three levels of productivity, which are separate from AI utilization levels) are explained in [Understanding Developer Productivity](https://lib.findy.co.jp/productivity/why-measure.md).

### Distribute

Distribute the skills and agents you create across the organization as a [plugin](https://lib.findy.co.jp/ai/plugin.md). Managing the plugin in an internal repository lets members install and update it with one command, and every improvement reaches everyone once it is merged.

Keep the repository open so that anyone, not just the adoption owner, can propose improvements. When people can request a skill or suggest a fix through a pull request, AI adoption becomes an effort of the whole organization. Moving skills that live in individual teams into the plugin also lets other teams use them and returns improvements to the whole company.

### Embed

Tools that are only built and distributed eventually go unused. Keep mechanisms running that make people aware of them and able to use them well.

| Measure | Contents |
| - | - |
| Automatic update notifications | Summarize the changes merged into the plugin repository the previous day and post them to chat daily |
| Announcements at regular meetings | Regularly introduce adoption activities and new skills at engineering meetings |
| Vibe coding pair programming | The adoption owner watches a junior engineer implement through dialogue with AI and advises on prompting and usage |
| Screen sharing | The adoption owner streams their screen while developing with AI, and anyone interested can watch and ask questions |
| Strengthening fundamentals | Encourage and support learning and certifications in software engineering and computer science |

Fundamentals matter because judging whether AI output is good requires foundational knowledge. At Level 2 in particular, judging whether a design AI proposes is correct calls for language-independent knowledge such as databases, networking, algorithms, and computational complexity.

## Points to keep in mind

* **No single measure raises productivity at once.** Accumulate small improvements and keep facing the problems in front of you.
* **Do not make using AI the goal.** First confirm results with productivity metrics, then look at how AI is used. Look at how it is used, not how much.
* **The adoption owner should not do everything.** Through mechanisms that let anyone improve skills, make continuous improvement an effort of the whole organization.
* **Basics first, AI usage after.** With a weak foundation, neither guardrails nor AI will deliver results.

## Related pages

> [card] [Agentic Workflow](https://lib.findy.co.jp/ai/agentic-workflow.md)
>
> The core of Level 2: delegating planning, implementation, and verification to AI.

> [card] [Plugins](https://lib.findy.co.jp/ai/plugin.md)
>
> The mechanism behind the "distribute" step, delivering skills and more across the organization.

> [card] [Understanding Developer Productivity](https://lib.findy.co.jp/productivity/why-measure.md)
>
> The definition and three levels behind the productivity metrics you read when visualizing.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.