Scaling Synthesis Coding in Your Organization

Adopting synthesis coding requires an organizational transformation. Installing the tools is straightforward compared with changing how engineers plan, implement, review and learn. That cultural shift determines whether the organization gains a lasting capability.

This article expands on organizational considerations I originally included in my Claude Code technical implementation guide. Based on feedback from Guthrie Collin, I've moved this content into a dedicated article to better serve engineering leaders who need organizational guidance without wading through implementation details first.

Updated December 19, 2025: Added the conductor framing for managing distributed AI development, drawing on OpenAI's December 2025 Sora for Android case study.

From tool user to conductor

Engineers accustomed to writing every line of code must learn to direct AI agents. Patrick Hum and RJ Marsan described the experience in OpenAI's Sora for Android case study: “It felt less like using a tool and more like managing a team.”

A conductor coordinates the players, provides direction, ensures quality and maintains a coherent vision across the parts. Synthesis coding engineers do the corresponding work: architect systems, provide context, review output and integrate changes while AI agents handle implementation. The engineer's responsibility expands with the amount of work they can direct.

Coordination still limits the gains from parallel work. OpenAI's account describes decisions, feedback and integration becoming bottlenecks as the team ran more Codex sessions, and connects the problem to Brooks's Law. Adding sessions creates more work to coordinate; it does not establish a linear speedup. Assign agents work that can proceed independently, then plan explicitly for the decisions and integration that bring it together.

OpenAI later marked Sora unavailable as of April 26, 2026. The December 2025 engineering account remains a historical case.

I've watched engineering organizations approach AI-assisted development in two ways. Some treat it as installing a new IDE plugin — deploy it, send an email, move on. These organizations see mixed results and often abandon the approach after a few months. Others treat it as a practice transformation requiring training, process changes, and sustained attention. These organizations see consistent productivity improvements.

Understanding the real costs

Check Anthropic's current pricing for the plans and usage model your team will use. Subscription and API charges belong in the budget alongside setup, training, review and support. Separate one-time setup costs from recurring costs so the next expansion decision uses the appropriate total.

Budget 20–40 hours per engineer in the first month for training, supervised practice and adapting the team's workflow. That is my planning allowance; use the role-specific curriculum below to decide where the time goes. Senior engineers need time to develop organizational patterns others can follow. Junior engineers need more structured practice and coaching.

Allow two to three months for teams to adapt their code review, testing and deployment processes, including the possibility of reduced velocity during that period. Putting that allowance in the plan makes room for learning without treating every early slowdown as failure. In a regulated industry, budget for any additional review checkpoints or audit logging your work requires.

Budget 2–4 hours per month per engineer for continuing education: sharing what is working, learning new capabilities and refining patterns. The tools and the team's practices will keep changing.

The productivity case

In 2025, I saw these results across multiple engineering teams after they reached proficiency:

MetricBeforeReported resultMeasurement
Feature velocityBaseline+30-40%Measured in story points completed
Bug resolution timeBaseline-25%Time from report to fix
Code review cycles2.3 average1.7 averageIterations before merge
Test coverage67%84%Automated test coverage

I attributed the velocity improvement primarily to three sources: faster initial implementation, more comprehensive testing that caught bugs before review, and systematic refactoring that had previously been postponed. These are useful mechanisms to investigate in your own team, alongside the time spent directing, checking and integrating the work.

For a team paying engineers six-figure salaries, even a modest gain in useful engineering capacity can repay subscription costs many times over. Realizing the gain takes investment in training, review and the way the team works.

Agree on the trial before collecting results

Use this worksheet with the developers and reviewers who will do the work. Fill in the right-hand column before the pilot begins.

FieldTeam's agreement
DecisionWhat will the evidence let us expand, change or stop?
Eligible workWhich task types and repositories are included? Record exclusions and their reasons.
ParticipantsWho implements, reviews and accepts the changes? Record relevant familiarity with the codebase.
ComparisonWhich comparable work will we use as a baseline, and how will tasks enter each group?
CompletionDoes “done” mean approved, merged, deployed or accepted by a user? Choose one primary endpoint and retain the others.
ObservationWhen does the trial end? How long after release will each change be checked for defects?
Quality requirementsWhich tests, security checks and review standards apply to every change?
Expansion criteriaWhat improvement would justify expansion? What deterioration would rule it out?
Account and dataWhich product, plan, model and connection route are authorized? Which inputs and actions are permitted?
OwnerWho records the results and makes the decision?

Keep the comparison within recognizable task classes. A documentation edit and a concurrency bug are both tickets, but treating them as interchangeable completed units will distort the result. Separate them in the report. Record changes in task scope, dependencies and reviewer availability as the trial proceeds.

A before-and-after comparison is useful operational evidence, with limits. The team may have learned the codebase, improved its tests or received easier work during the pilot. Those changes can affect the outcome. Alternating or assigning comparable work across workflows can strengthen the comparison where practical, but a short team trial still won't establish a universal productivity effect.

Don't average story points from different teams into a company-wide productivity number. If the team uses points to plan its work, retain them as local context. Report the actual task counts and task types alongside elapsed time and effort.

Follow every attempted change through acceptance

Keep one record per task. Include abandoned AI attempts, changes that were completed by another method, and work still unfinished when the trial ends. A report that retains only successful AI-assisted changes hides part of the cost.

MeasureWhat to record
Identity and scopeTicket or change ID, task type, acceptance criteria and any scope changes.
WorkflowAI use, tool and model versions, relevant settings, and whether the approach changed during the task.
Delivery timeStart, ready-for-review, approval, merge and release timestamps, where applicable.
Implementation effortActive human time understanding the task, directing the tool, editing and checking the result.
Review effortActive reviewer time, requests for changes and substantial rounds of revision.
ReworkTime correcting the implementation before acceptance and fixing related defects after release.
OutcomeAccepted, abandoned, completed another way or still open, with the reason and evidence link.
QualityFailed acceptance checks, escaped defects and their severity, using the agreed observation window.
CostAttributable tool usage and the allocation of subscriptions, setup, training and support costs.

Elapsed time and active effort answer different questions. A change can spend less time in implementation and more time waiting for review. Keep the ready-for-review and review-start times if the queue is central to the decision. Don't count that waiting period as active reviewer effort.

Keep effort categories from overlapping. Time spent fixing a review finding belongs in rework; it shouldn't also appear as new implementation work in the total. If several people work together, distinguish their combined person-hours from the elapsed meeting time.

At the end, report how many eligible tasks were attempted, how many reached the chosen endpoint, and how many remain open. Show the distribution of completion times within each task class, including the slow cases. Keep unfinished work visible alongside completed work; treating it as zero-duration work would understate elapsed time.

For defects, record the denominator and exposure window. “Defects per accepted change within the agreed period” is more interpretable than a bare defect count, but it still needs severity and task context. A change released near the end of the trial may not yet have had the full observation period. Mark that result incomplete and finish the observation before claiming a quality comparison.

Count work that moved to someone else

Ask reviewers where their effort went. Were they checking ordinary implementation details, reconstructing undocumented decisions, or repairing inconsistent interfaces across parallel changes?

A pilot can reduce the author's typing while increasing a senior engineer's review workload. It can also make exploratory work useful even when no generated code is merged. Record those outcomes in their own terms. Neither should disappear because the dashboard counts only merged lines.

Use the same discipline with cost. Subscription fees are one input. Setup, training, additional compute, review and rework also consume resources. Record one-time setup separately from recurring costs so the next rollout decision can use the appropriate total.

If you convert saved hours into money, show the labor-rate assumption and avoid counting the same hours twice. Saved capacity isn't automatically a reduction in payroll spending. Explain what the team did, or expects to do, with that capacity.

Rolling out to your team

I recommend a twelve-week sequence that develops experienced practitioners first, equips team leads to teach the approach, and then integrates it into ordinary engineering work. The weeks are a planning sequence; readiness and quality determine when to expand.

Start with your strongest engineers

In the first two weeks, work with 3-5 experienced engineers who have strong opinions about code quality. You want people who will direct the AI, not follow it. They need to be willing to document what they learn, and they need credibility with the broader team — others will trust their assessments. Pick engineers from different specializations so you get diverse perspectives on what works.

By the end of week two, this pilot group should have documented patterns that work for your specific codebase, anti-patterns to avoid, an initial assessment of which task types benefit most, and rough productivity metrics comparing before and after on comparable tasks.

Expand to team leads

In weeks three and four, each team lead learns the framework and adapts it to their team's context. The focus shifts to practical integration: how to review AI-assisted code, what human oversight is required for different types of changes, and team-specific patterns based on each team's codebase and challenges. Team leads also identify which of their engineers will need extra support during the broader rollout.

By week four, each team should have documented team-specific guidelines, an updated code review checklist, a training plan for the full rollout, and an established metrics baseline.

Train the full team

Weeks five through eight are the full rollout. Train the entire team on synthesis coding principles through half-day workshops, then run pair programming sessions matching experienced practitioners with engineers still learning. For the first two weeks, daily standups should include discussion of AI-assisted development — what's working, what's confusing, what patterns are emerging. Weekly office hours give people space to ask questions and share discoveries.

Watch for common mistakes during this phase. Junior engineers accepting AI output without understanding it. Teams skipping the architectural planning phase in their rush to produce code. Quality standards eroding under pressure for speed. Inconsistent application across team members, with some embracing the approach and others barely using it.

Address these directly. Require junior engineers to explain AI-generated code before it can merge. Make architecture review a required step before implementation begins. Add automated quality checks in your CI pipeline. Hold regular retrospectives focused specifically on what's working with AI-assisted development and what isn't.

Integrate into your processes

Weeks nine through twelve are about making this permanent. Update your coding standards to address what AI-assisted code should look like. Revise code review guidelines to cover how reviewers should approach AI-assisted PRs. Set testing requirements including coverage expectations for AI-assisted code. Consider how AI can help maintain documentation.

Look for velocity to stabilize and improve, bugs to decline as testing improves, and review time to fall as initial code quality improves. These are the outcomes you are working toward. Survey engineer satisfaction monthly and investigate a result that moves in the wrong direction.

Training by experience level

Senior engineers already have architectural intuition and need to understand how to maintain that authority while accelerating implementation. Mid-level engineers need balanced training on both effective usage and maintaining their growing skills. Junior engineers need the most attention to ensure AI assistance builds rather than replaces fundamental skills.

For senior engineers, plan 8-12 hours covering architectural direction, effective prompting for complex systems, security and quality review of AI-generated code, and how to teach and mentor others in this approach. The key lesson is maintaining system coherence across AI-assisted changes while knowing when to accept AI suggestions versus when to override them.

For mid-level engineers, plan 16-20 hours covering synthesis coding fundamentals, hands-on implementation through real tasks, quality and testing practices, and your organization's codebase-specific patterns. Pair sessions with senior engineers are particularly valuable at this level.

For junior engineers, plan 24-32 hours with extra emphasis on programming fundamentals. This group needs supervised AI-assisted development before working independently, practice explaining AI-generated code, and training in recognizing when AI output is incorrect. They also need explicit guidance on building judgment over time.

Check that the training worked

Ask a participant to explain a proposed change, trace its data flow, identify a missing test and repair a defect. These checks reveal what the planned training has achieved and where more support is needed.

Use the gaps in those exercises to choose the next session. If a participant cannot explain how a change checks who may access the data, review its authorization paths together. If a design puts business rules in the wrong layer, work through it with an architect or experienced maintainer. For debugging practice, have the engineer trace an unfamiliar failure, form a hypothesis and use a test to distinguish it from an alternative. AI assistance can be part of these exercises; the participant still needs to explain and check the resulting code.

Team leads should turn repeated findings into review guidance and arrange support before expansion: pairing on an unfamiliar part of the codebase, a focused workshop, or access to a maintainer during the next task. Recheck the missed skill on a different change. Keep support time in the cost record so the expansion decision accounts for the people needed to sustain the workflow.

The critical rule for junior engineers

Some work must be done without AI assistance to build fundamental skills. For the first three months, I recommend junior engineers do about half their tasks traditionally. From months four through six, that drops to about 30%. After six months, maintain 10-20% traditional development ongoing.

The specific tasks matter. Junior engineers should do traditional development for algorithm implementation, debugging complex issues, reviewing others' code, and participating in architecture discussions. These activities build the problem-solving skills, system understanding, quality judgment, and design thinking that AI can accelerate but cannot replace.

Tracking success

Use weekly measures to spot adoption and quality problems early. These are initial management targets, to be interpreted alongside the work the team is doing:

MetricTargetRed flag
Training completion100% of each cohort within 4 weeks<80% of that cohort after 4 weeks
AI tool daily active users>80% of engineers<50% after rollout
Architectural planning usage100% of featuresEngineers skipping planning
Code review pass rateStable or improvingDeclining quality

Track outcomes monthly as well. I would use the following goals to focus the rollout:

MetricTargetMeasurement
Feature velocity+25-40% vs. baselineStory points or features shipped
Bug escape rate-20% vs. baselineBugs found in production
Engineer satisfactionStable or improvingMonthly survey
Time to proficiency<6 months for mid-levelTime until engineer is net positive

Watch for anti-metrics that indicate adoption is going wrong. If engineers can't explain their own code, AI assistance has become a crutch. If system design is degrading, AI is driving decisions that should be human. If junior engineers aren't developing fundamental skills, adjust training immediately.

Make the expansion decision from the record

Use the criteria chosen at the start. If accepted work reaches users sooner, quality remains within the agreed requirements, review capacity is sufficient and the recurring cost is justified, expand to the next defined group of work. Record which conditions made that decision possible.

If the result is mixed, name the limiting factor. A long review queue calls for a different change than poor task selection or an account configuration that excludes the required data. Adjust the workflow and specify the evidence needed to evaluate that adjustment.

Stop a workflow that fails the agreed acceptance requirements. Keep the attempted work and the reasons in the report; they are part of the result.

The decision record can be brief: the work evaluated, the comparison used, the observed outcomes, the unresolved measurements and the next authorized scope. Attach the task records so another engineer can follow the conclusion back to the changes.

Security and compliance

An account policy is part of the trial configuration. Record the plan, connection route, relevant settings and the date the documentation was checked. A policy conclusion about one account should not silently carry over when a participant signs in through another.

Account policies as documented October 1, 2026.

For example, Anthropic's Claude Code data-use documentation distinguishes consumer and commercial use. Free, Pro and Max accounts can enable use of their sessions for model improvement. Under commercial terms, Anthropic says it does not train generative models on submitted code or prompts unless the customer has chosen to provide data for that purpose.

Training, retention and feedback are separate questions. The same documentation describes retention by account and settings, local transcript storage, and distinct feedback submission paths. The consumer privacy documentation also describes safety-review and feedback uses. Record the applicable treatment before sending the pilot's code or data. “Not used for training” does not mean “never transmitted or retained.”

Keep credentials and unauthorized data outside the agent's available inputs. A Git ignore rule controls which intentionally untracked files Git normally ignores; it doesn't revoke a process's ability to read them or prevent transmission. Already tracked files are unaffected by an ignore rule. Check the tool's actual file and network permissions separately, using harmless test data.

Output rights need their own check. Anthropic's commercial terms allocate rights in outputs between the parties, subject to the terms and applicable law. That allocation doesn't establish that every generated passage is free of third-party rights. Keep the organization's licensing and code-review process in place, and have the contract owner resolve questions about the applicable agreement.

For regulated industries such as healthcare, finance and defense, map the workflow to the applicable compliance framework. Keep audit trails, define the human review required for compliance-critical code and update the development process documentation. Have the responsible specialists determine whether AI assistance changes certification requirements.

Include the tools in the vendor security assessment. Review retention, jurisdiction and data-sovereignty requirements, and assess whether particular codebases require an approved private or on-premises model. Continue reviewing suggested libraries and copied code for license compatibility, including copyleft obligations.

Failure patterns I've seen

The "magic wand" failure happens when teams expect AI to replace engineering judgment. Engineers stop thinking critically about generated code. Quality degrades, bugs increase, and technical debt accumulates faster than before. Prevention: emphasize synthesis — human plus AI — from the start. Require code explanation before merge. Maintain strict quality standards.

The "abandoned rollout" failure happens when organizations install tools but don't invest in training or process changes. Usage is inconsistent. Some engineers find value while others struggle. The organization abandons the approach after 3-6 months, concluding it "doesn't work for us." Prevention: treat this as organizational transformation, not tool deployment. Follow a phased rollout. Measure and adjust.

The "junior engineer crutch" failure happens when junior engineers rely entirely on AI. They can produce code but can't explain it or debug it. They plateau and can't grow into senior roles. The organization loses developing talent. Prevention: require traditional development for learning tasks. Require code explanation. Monitor junior engineer growth metrics actively.

The "security blind spot" failure happens when AI-generated code isn't reviewed for security with the same rigor as human-written code. Vulnerabilities slip through and may not be detected until an incident. Prevention: security review applies equally to all code regardless of origin. Train reviewers on AI-specific patterns to watch for. Include security in automated checks.

Implementation checklist

Before rollout:

  • Executive sponsor identified and committed
  • Budget approved (tools + training + productivity dip)
  • Pilot team selected (3-5 senior engineers)
  • Success metrics defined and baseline established
  • Security and compliance review completed

During pilot (weeks 1-4):

  • Pilot team using tools daily
  • Patterns and anti-patterns documented
  • Team-specific guidelines drafted
  • Code review process updated
  • Initial metrics captured

During rollout (weeks 5-8):

  • All engineers trained (appropriate curriculum by level)
  • Pair programming sessions completed
  • Quality standards documented and enforced
  • Automated checks in CI pipeline
  • Weekly retrospectives held

After rollout (weeks 9-12):

  • Processes fully integrated
  • Metrics showing expected improvement
  • Ongoing education scheduled
  • Patterns library established
  • Success criteria met or recovery plan in place

Build the advantage

I believe synthesis coding is a major change in how software gets built. Organizations that master it can create a sustained advantage: more useful engineering work, higher quality and more room for their people to solve difficult problems. Teams that ignore it will have to compete with organizations developing that capability.

The organizations I have seen make the most of it invested in training, adapted their processes and maintained quality standards while increasing velocity. That is the work I recommend to engineering leaders. Start with a pilot that teaches you how your team works with AI, turn those lessons into a disciplined practice, and scale with the people and processes needed to sustain it.


This article is part of the synthesis coding series. For technical implementation details and code examples, see Synthesis Coding with Claude Code: Technical Implementation and Workflows.