You introduced AI coding tools. At first, everything went smoothly. But a month later, problems started to surface. Understand the changes before you can respond to them.
1.1 Two Scenarios
Scenario 1: Out of Control
Your team adopted AI coding tools. Everyone was excited at first -- efficiency really did improve. But a month later, problems began to emerge:
- The codebase was filled with inconsistent styles (AI generated different coding styles across different conversations).
- Some critical modules had been "casually" modified by AI, introducing hidden bugs.
- Code review became a disaster -- reviewers could not understand AI-generated code.
- When new members joined, no one could clearly describe the system's architecture.
AI did not replace your team, but it changed how your team works. And you were not ready for that change.
Scenario 2: Empowered
Another team (a teaching scenario contrasting with the first) also adopted AI coding tools. But their approach was different:
- The team first established AI coding standards: which scenarios to use AI for, and which not to.
- All AI-generated code had to pass verification before being committed.
- Every project had to produce an architectural blueprint before starting.
- Weekly code quality audits checked for architecture drift.
Results:
- Development efficiency improved markedly (several-fold in this team's comparative observation).
- Code quality remained stable.
- Team members felt excited about the new tool, not anxious.
Key difference: The first team let AI drive the development process. The second team let AI work within a defined framework.
1.2 Three Changes Brought by AI Coding
AI coding is not a "tool upgrade" -- it is a "restructuring of how work is done." The changes it brings are not linear but systemic: one change triggers another.
Change 1: Dramatic Increase in Development Speed
A feature that traditionally took two days might take only two hours with AI coding. This is the most obvious change and the first thing managers notice: "Great, efficiency has improved!" Note that publicly available research shows wide divergence in magnitudes: controlled experiments have measured speedups (e.g., GitHub's Copilot experiment), while a randomized controlled trial with experienced developers on mature codebases they knew deeply measured a slowdown (METR's 2025 study)--the effect depends heavily on task type, familiarity with the codebase, and how the tools are used. The "two days to two hours" framing here is an illustration for well-bounded small features, not a universal promise.
But efficiency gains trigger a chain reaction. Delivery cycles shorten, so the business side naturally expects higher delivery frequency -- "If you can build a feature in two days, you should be able to build ten in a month, right?" But "fast delivery" does not equal "delivering the right thing fast" -- the bottleneck shifts from "writing code" to "reviewing code." Before, a feature took two days to develop and half a day to review -- review time was a quarter of development time. Now, AI writes it in two hours, but review still takes half a day -- review time is now three times development time.
What this means for management: You need to rethink how you plan projects and estimate progress. You can no longer use "coding time" to estimate effort, because coding time is approaching zero. The true bottleneck is now "verification" and "integration" -- you need to invest more resources in these two areas.
Change 2: Explosion in Code Volume
AI coding tools tend to generate more code. A developer using AI might see their output grow several-fold. This sounds like a good thing -- but the explosion in code volume brings three new problems.
First, the workload of code review increases dramatically. Before, a PR might have 100-200 lines that a reviewer could quickly scan. Now, AI-generated PRs might have 500-1000 lines, requiring more time and making it easier to miss issues.
Second, the codebase expands faster. If your codebase was 50,000 lines a month ago, it might be 150,000 lines a month from now -- but the business complexity has not increased that much. Extra code means higher maintenance costs.
Third, technical debt may accumulate faster. AI tends to "solve the problem" without considering long-term maintainability. One "quick implementation" today, another "quick patch" tomorrow -- technical debt is like a high-interest loan; the interest compounds.
What this means for management: You need stricter code structure management. Regularly check the codebase's health. Do not wait until the "codebase explodes" to deal with it.
Change 3: Changes in How Knowledge Is Captured
In traditional development, developers understand a system by "writing code" -- every line is personally typed, and by the time the code is written, the system is understood. With AI coding, developers may not have "written" the core code, but they still need to "understand" it.
It is like hiring a construction crew to build your house. The house is built, you move in, but you do not understand the house's structure -- where the load-bearing walls are, where the pipes are, where the wiring runs. When you want to remodel, you do not know where to start.
What this means for management: Code review and architectural documentation are more important than ever -- for code that was not written by hand, they are the primary way developers build an understanding of the system. The onboarding process for new members needs to change -- you cannot rely on "reading the code" to understand the system, because half the code might have been written by AI and even the committer does not fully understand it. Knowledge transfer within the team needs a more structured approach -- documentation, sharing sessions, code walkthroughs, rather than "just go read the code."
1.3 The Manager's New Role
Three changes mean that the manager's role needs to expand. Not "abandon the old role," but "layer new roles on top of the old one."
From "Managing People" to "Managing Processes"
Traditional management focuses on "who is doing what" -- who is building this feature? Who is fixing that bug? In the AI coding era, the question becomes "what is the process" -- because the process determines the quality of AI's work, not "who is doing it."
Why? Because AI has no sense of responsibility or professional ethics. It will not proactively think "is this the best approach?" -- it only executes the instructions you give. If you do not have a clear process (blueprint before coding, verification before commit), AI will follow its own "default process" -- which is "generate code quickly, do not worry about quality."
So managers need to shift from "assigning tasks" to "designing processes." If the process is well-designed, both AI and the team can work efficiently. If the process is poorly designed, AI will create chaos.
From "Managing Results" to "Managing Gates"
Traditional management focuses on "does the code run" -- if it is deployed and no bugs appear, it is good. In the AI coding era, code almost always "runs" -- because AI-generated code is almost always syntactically correct. But "runs" does not equal "good quality" -- passwords might be stored in plain text, APIs might lack access control, database queries might have injection risks.
So managers need to shift from "checking results" to "designing gates" -- setting quality checkpoints along the path from code to production. Each checkpoint has clear standards; only code that passes can proceed to the next stage.
From "Managing Individuals" to "Managing Standards"
Traditional management focuses on "how well this developer is doing" -- look at code quality, delivery speed, bug rates. In the AI coding era, AI handles most of the coding work, and individual differences are flattened by AI -- a junior developer and a senior developer using AI might produce code of similar quality.
But there is one problem AI cannot solve: following team conventions. AI will not naturally follow your team's coding standards like a human would -- it does not know if your team uses camelCase or snake_case, where your APIs should be placed, or what format your error handling should use. So managers need to shift from "managing individuals" to "managing standards" -- are the standards clear? Are they understood and followed by AI? Do the standards themselves need updating?
1.4 Common Manager Concerns
Concern 1: AI-generated code quality is uncontrollable
Fact: AI-generated code quality does vary, but by establishing a verification system, quality can be controlled. The key is "where to control quality" -- before commit (verification) or after deployment (bug fixing)?
Recommendation: Establish a "pre-commit verification" gate. All AI-generated code must pass functional, architectural, and security verification before it can be committed.
Concern 2: Team skill degradation
Fact: Developers who rely on AI for extended periods may lose the ability to code independently.
Recommendation: Do not ban AI coding. Instead, require developers to understand the code AI generates. The verification step is a forced learning opportunity -- developers must understand the code in order to verify it.
Concern 3: Team dependence on AI
Fact: Developers ask AI about everything instead of thinking for themselves first.
Recommendation: Clearly define "which scenarios to use AI for and which not to." For example:
- Routine CRUD features: AI can be used.
- Core business logic: Must be thought through first, then validated with AI's help.
- Architecture decisions: AI provides references, humans make decisions.
1.5 The Manager's Core Tasks
Based on the analysis above, the manager's core tasks can be summarized into three areas.
Task 1: Establish Standards
Define the team's AI coding standards, specifying:
- Which scenarios to use AI for.
- How AI-generated code should be verified.
- How architectural blueprints should be maintained.
- How code quality should be audited.
Task 2: Train the Team
Help team members learn the correct AI coding methods:
- Basic training: Six-Step Workflow, Three Disciplines.
- Advanced training: Use cases and methods for the 14 skills.
- Continuous learning: Retrospectives, sharing, improvement.
Task 3: Continuous Improvement
Establish feedback mechanisms to continuously optimize the process:
- Regular code quality audits.
- Project retrospectives.
- Process improvement iterations.
Chapter Summary
AI coding is not a "tool upgrade" -- it is a "restructuring of how work is done." Three changes -- increased development speed, code volume explosion, and changes in knowledge capture -- trigger chain reactions that require managers to rethink project planning, code review, and knowledge transfer. The manager's role needs to expand from "managing people" to "managing processes, managing gates, and managing standards" -- because processes determine AI's quality, gates control AI's output, and standards constrain AI's direction. In the next chapter, we will overview the 14 skills a manager needs to know.