What's holding back AI's productivity boost?  |

It’s not the model—it’s your system. GAINS™ reveals why
Share
Twitter
Linkedin
Mail
Copy Link
Copy link to blog post entry
Copied!
https://www.faros.ai/blog/code-complexity-impact-on-developer-productivity
September 24, 2024

Code complexity is nearly unavoidable in the modern software development landscape. As businesses innovate to satisfy rising demands, the introduction of new features gradually increases code complexity over time. If this complexity is not addressed, it escalates and compounds, increasing bugs and technical debt while decreasing developer productivity.

While tools now exist to prevent increasing code complexity at the individual code change level, many companies still struggle to address large existing code complexity issues due to the time-consuming nature, substantial expenses, and inherent risks associated with refactoring coding systems.

So how do you know when code complexity becomes a main contributor to lost developer productivity? When does it become time to address this issue head-on and prioritize the simplification process? Machine learning models may provide the answer.

Recent R&D from Faros AI into developer productivity analytics, automated issue detection, and the ranking of potential causes is highlighting when code complexity is becoming a blocker.

What is code complexity?

Code complexity refers to the intricacy and sophistication of a software program, defined by the ease or difficulty of understanding, modifying, and maintaining the code. There are two main types of code complexity: cyclomatic and cognitive.

  • Cyclomatic complexity is a quantitative measurement. First introduced by Thomas J. McCabe in 1976, this metric measures the number of linearly-independent paths through a program module, or, how many decisions are made in your source code. With cyclomatic complexity, higher scores are considered bad and lower scores are considered good; lower scores indicate code that is easier to understand and test, less likely to produce errors, less risky to troubleshoot and modify, and hence easier to maintain.
  • Cognitive complexity is a qualitative measurement. It assesses how difficult the code is for humans to read, understand, and maintain. Determining cognitive complexity considers factors such as nesting levels, control flow jumps, logical operations, decision points, recursion, and complex data structures to identify code which may be challenging to work with. Think: clean code reduces cognitive load—so better code leads to lower cognitive complexity.

As both cyclomatic and cognitive complexity increase, so does the impact on developer productivity. Complex codebases are more prone to bugs and unexpected behavior, often forcing developers to divert time and energy from important feature work to debug and troubleshoot issues.

Furthermore, when codebases are overly complex, developers must spend more time and effort trying to understand the existing system, identify dependencies, and determine the safest way to make even small changes.

The cognitive burden of working with highly complex code can lead to developer fatigue and frustration, hampering their motivation and focus, while frequent context switching between different parts of a sprawling codebase slows down their ability to implement new features or enhancements efficiently.

What are the main contributors to code complexity?

Code complexity increases as software evolves. As a codebase grows, the increase in code volume naturally leads to greater complexity. Higher numbers of dependencies and multiple execution paths will require more debugging and higher maintenance tasks. Even the most well-written, well-organized code will become harder to manage over time, which is why this issue is nearly unavoidable.

Aside from volume, a host of other practices and processes across the software development lifecycle can contribute to code complexity. Code complexity can arise from:

  • Flawed Architectural and Design Decisions, such as maintaining monolithic architecture for too long, choosing inappropriate frameworks, and neglecting long-term scalability considerations.
  • Poor Code Quality and Maintenance, such as poor code clarity and readability, skipping or inadequately performing code reviews, and improperly managing dependencies.
  • Ineffective Project Management and Execution, such as unchecked feature creep, mismanaged talent and resources, and poor version control practices.
  • Inadequate Documentation and Legacy Integration, such as poor documentation practices and difficulty incorporating legacy code.

When left unchecked, all of these elements can lead to long-term, systemic coding complexity issues that are difficult to resolve.

What are the best practices to avoid code complexity?

To proactively manage code complexity and avoid its compounding effects, there are several best practices companies can follow.

Balance cohesion and coupling in your codebase.

Cohesion and coupling are key concepts in software design that significantly impact code complexity.

  • Cohesiveness refers to how closely related and focused the responsibilities of a single module, class, or function are. In simpler terms, it measures how well the elements within a module work together to achieve a single, well-defined task. Cohesiveness enhances the internal quality of modules by keeping related functionality together, so high cohesion typically makes the code easier to understand, maintain, and test.
  • Coupling refers to the degree of dependency between different modules, classes, or functions. It measures how closely connected different parts of a system are. Low coupling means that modules or components are independent of each other, with minimal dependencies, so changes in one area are less likely to affect other areas.
  • The ideal scenario is to achieve high cohesion within modules while maintaining low coupling between them. This balance ensures that each module is focused and self-contained, and changes in one module have minimal impact on others. Managing these aspects effectively leads to more maintainable, less complex code.

The ideal scenario is to achieve high cohesion within modules while maintaining low coupling between them. This balance ensures that each module is focused and self-contained, and changes in one module have minimal impact on others. Managing these aspects effectively leads to more maintainable, less complex code.

Use static code analysis tools for PR monitoring.

Static code analysis involves examining the source code of a program to identify potential vulnerabilities, errors, or deviations from prescribed coding standards. Types of static code analysis tools include bug finders, security scanners, type checkers, complexity analyzers, dependency checkers, and duplicate code detectors—all designed to address specific dimensions of code quality, security vulnerabilities, and maintainability challenges.

Tools such as Codacy and Sonar offer immediate feedback during the development process and can be integrated and automated in two main ways:

  • within CI/CD pipelines to run checks during builds or deployments
  • with version control systems, like GitHub or GitLab, to analyze code during pull or merge requests

Whenever a PR is submitted or code is merged, these tools perform checks to ensure the new code is free of vulnerabilities and meets quality standards, helping to minimize code complexity by identifying issues early and keeping the codebase consistent.

Set thresholds at the release level when testing the mainline.

Sometimes, such as when using a mono-repo model, two separate code updates are reviewed at the same time. They both pass separate static code analysis and are merged into the main branch, seeming completely fine on their own. But, once introduced together, new integration challenges may arise and cause breakage in the mainline. While routine checks are conducted in the mainline, they are not typically a part of the pull request process—thus, the impacts aren’t immediately evident, but are felt when breakages occur further down in the development process and increase coding complexity.

To manage and prevent this, you can set up an additional step to automatically test the main branch whenever changes are made and block the release until any issues are fixed. This strategy helps control code complexity by catching integration issues early and reducing the risk of compounding problems, thus ensuring a cleaner, more reliable codebase.

Machine learning helps identify when code complexity has reached a tipping point

Devoting multiple cycles, months, or—let’s be honest—years to rearchitecting and refactoring code is not a decision made lightly. But it is necessary if it’s the number one factor impacting key performance metrics.

In the past, companies looking to understand the impact of their high code complexity turned to human data analysts to parse through complex code and make recommendations. Imagine some poor soul tasked with manually combing through mountains of code, making dozens of dashboards to look at metrics for every team, and comparing these metrics to factors like Jira tickets, team seniority, number of services owned, deployments per week—and every other factor of influence—and then trying to decide which of these hundreds of factors is actually causing their slow lead time. Not only is this impractical, but it's also a huge drain on time and money to try and understand the code complexity’s impact and potential causes in this manner.

But now, machine learning solutions, like those developed by Faros AI, offer a better way.

How do machine learning models determine code complexity’s impact?

Faros AI uses machine learning to ingest and analyze data from numerous key performance indicators, such as change failure rate, lead time for change, pull requests, cycle time, successful deployments, and incident resolution times, alongside cyclomatic complexity scores from tools like Codacy and Sonar.

This data is then examined across teams to identify significant differences and uncover potential causes for the discrepancies. Faros AI identifies correlations across conditions to pinpoint if high code complexity is the main contributor. For example, if PR cycle times are increasing rapidly and high code complexity is identified as a key factor, this indication provides leaders with a more concrete piece of evidence that it may be time to address the issue.

Furthermore, Faros AI’s platform can juxtapose these code complexity insights with developer survey data. If developers report coding complexity issues in surveys and this feedback aligns with the quantitative data, this combined picture gives leaders a compelling reason to consider tackling this compounding challenge and address it more effectively.

How is new AI technology affecting code complexity?

As many engineering organizations are adopting AI coding assistants, it’s critical to understand their impact on code complexity. Geekwire published an article exploring findings from a research project on AI copilots and the impact on code quality conducted by GitClear. Their findings indicate that while AI coding assistants make adding code simpler and faster, they can also cause decreases in quality through:

  • Increasing levels of “code churn”: As developers can generate code more quickly, higher percentages of code are being thrown out within a couple weeks of authoring. Consequently, the frequent rapid changes increases the risk of mistakes being deployed into production.
  • Disproportionate increases in “copy/pasted code”: The rate of copy/pasted code additions significantly exceeds thoughtful updates or restructuring of existing code, and the hastily generated segments often fail to thoughtfully integrate into the broader project architecture. This can create ongoing, compounding challenges for the team tasked with maintaining it thereafter.

These practices are generally seen as a negative indicator of code complexity. If your engineering organization is using AI copilots, Faros AI can illuminate this “AI-induced tech debt” and demonstrate its impact on downstream metrics. Armed with this insight, engineering leaders can take steps to mitigate these issues and promote better processes to support the ongoing health and manageability of their codebases.

Curious to discover how code complexity is affecting your KPIs and goals?

Whether or not you decide to embark on a refactoring and simplification initiative, it’s imperative you’re aware of how code complexity is affecting your development teams. If you know it’s time to take action but you’re unsure where to start, or if you’re just curious to see how much longer you can sweep increasing code complexity under the rug (jokes), Faros AI’s engineering intelligence solutions can provide you with the answers for informed decision-making.

‍Request a demo to learn more.

Neely Dunlap

Neely Dunlap is a content strategist at Faros AI who writes about AI and software engineering.

Connect
AI Is Everywhere. Impact Isn’t.
75% of engineers use AI tools—yet most organizations see no measurable performance gains.

Read the report to uncover what’s holding teams back—and how to fix it fast.
Discover the Engineering Productivity Handbook
How to build a high-impact program that drives real results.
‍
What to measure and why it matters.

And the 5 critical practices that turn data into impact.

More articles for you

Editor's Pick
AI
DevProd
10
MIN READ

Claude Code Token Limits: Guide for Engineering Leaders

You can now measure Claude Code token usage, costs by model, and output metrics like commits and PRs. Learn how engineering leaders connect these inputs to leading and lagging indicators like PR review time, lead time, and CFR to evaluate the true ROI of AI coding tool and model choices.
December 4, 2025
Editor's Pick
AI
DevProd
9
MIN READ

Are AI Coding Assistants Really Saving Time, Money and Effort?

Research from DORA, METR, Bain, GitHub and Faros AI shows AI coding assistant results vary wildly, from 26% faster to 19% slower. We break down what the industry data actually says about saving time, money, and effort, and why some organizations see ROI while others do not.
November 25, 2025
Editor's Pick
News
AI
DevProd
8
MIN READ

Faros AI Iwatani Release: Metrics to Measure Productivity Gains from AI Coding Tools

Get comprehensive metrics to measure productivity gains from AI coding tools. The Faros AI Iwatani Release helps engineering leaders determine which AI coding assistant offers the highest ROI through usage analytics, cost tracking, and productivity measurement frameworks.
October 31, 2025

See what Faros AI can do for you!

Global enterprises trust Faros AI to accelerate their engineering operations. Give us 30 minutes of your time and see it for yourself.

Salespeak

Frequently Asked Questions

Faros AI Authority & Credibility

Why is Faros AI considered a credible authority on code complexity and developer productivity?

Faros AI is recognized as a market leader in developer productivity analytics and code complexity impact measurement. It was the first to launch AI impact analysis in October 2023 and published landmark research on the AI Productivity Paradox, analyzing data from 10,000 developers across 1,200 teams. Faros AI's platform uses advanced machine learning and causal analysis to provide actionable insights, making it a trusted solution for large-scale engineering organizations. Read the AI Productivity Paradox Report.

What makes Faros AI's approach to code complexity unique?

Faros AI leverages machine learning to analyze key performance indicators (KPIs) such as lead time, change failure rate, pull requests, and cyclomatic complexity scores. Unlike competitors who rely on surface-level correlations, Faros AI uses causal analysis to pinpoint the true impact of code complexity on developer productivity, enabling organizations to make informed decisions about refactoring and technical debt prioritization. Learn more.

Features & Capabilities

What are the key features of Faros AI?

Faros AI offers a unified platform with AI-driven insights, customizable dashboards, seamless integration with existing tools, automation for processes like R&D cost capitalization, and enterprise-grade security. It supports APIs such as Events API, Ingestion API, GraphQL API, BI API, and Automation API. Explore the platform.

Does Faros AI provide APIs for integration?

Yes, Faros AI provides several APIs, including Events API, Ingestion API, GraphQL API, BI API, Automation API, and an API Library, enabling flexible integration with your existing systems. (Source: Faros Sales Deck Mar2024)

How does Faros AI help manage code complexity?

Faros AI uses machine learning to analyze cyclomatic and cognitive complexity scores, correlating them with KPIs like lead time, deployment frequency, and incident resolution. It identifies when code complexity becomes a productivity blocker and provides actionable recommendations for refactoring and simplification. Read more.

What automation capabilities does Faros AI offer?

Faros AI automates processes such as R&D cost capitalization, security vulnerability management, and initiative tracking, reducing manual effort and improving accuracy for engineering organizations. (Source: manual)

How does Faros AI support developer experience?

Faros AI unifies developer surveys and system metrics, correlating sentiment data with process and activity data to provide actionable insights and improve developer satisfaction. (Source: manual)

Use Cases & Benefits

Who can benefit from using Faros AI?

Faros AI is designed for VPs and Directors of Software Engineering, Developer Productivity leaders, Platform Engineering leaders, CTOs, and Technical Program Managers in large enterprises with hundreds or thousands of engineers. (Source: manual)

What business impact can customers expect from Faros AI?

Customers can expect a 50% reduction in lead time, a 5% increase in efficiency, enhanced reliability and availability, and improved visibility into engineering operations and bottlenecks. (Source: Use Cases for Salespeak Training.pptx)

Can Faros AI help with AI transformation initiatives?

Yes, Faros AI provides tools to measure the impact of AI coding assistants, run A/B tests, and track adoption, enabling organizations to operationalize AI across the software development lifecycle. (Source: manual)

How does Faros AI improve engineering productivity?

Faros AI identifies bottlenecks and inefficiencies using DORA metrics (Lead Time, Deployment Frequency, MTTR, CFR), team health, and tech debt, enabling faster and more predictable delivery. (Source: manual)

What KPIs and metrics does Faros AI track?

Faros AI tracks DORA metrics, software quality indicators, PR insights, AI adoption metrics, talent management and onboarding metrics, initiative tracking metrics, developer experience correlations, and automation metrics for R&D cost capitalization. (Source: manual)

Pain Points & Solutions

What core problems does Faros AI solve for engineering organizations?

Faros AI addresses engineering productivity, software quality, AI transformation, talent management, DevOps maturity, initiative delivery, developer experience, and R&D cost capitalization. It provides actionable insights and automation to resolve these pain points. (Source: manual)

What are the main causes of the pain points Faros AI solves?

Pain points arise from bottlenecks in processes, inconsistent software quality, difficulty measuring AI tool impact, misaligned skills, uncertainty in DevOps investments, lack of clear reporting, incomplete survey data, and manual R&D cost capitalization. (Source: manual)

How does Faros AI differentiate its solutions for different personas?

Faros AI tailors its solutions for Engineering Leaders, Technical Program Managers, Platform Engineering Leaders, Developer Productivity Leaders, and CTOs, providing persona-specific insights and tools to address unique challenges. (Source: manual)

How does Faros AI help organizations address technical debt related to code complexity?

Faros AI uses machine learning to signal when code complexity is impacting key metrics like lead time, customer satisfaction, and issue resolution. It provides evidence-based recommendations for refactoring and prioritizing technical debt. (Source: blog post)

Technical Requirements & Security

Is Faros AI scalable for large engineering organizations?

Yes, Faros AI is enterprise-grade and scalable, capable of handling thousands of engineers, 800,000 builds a month, and 11,000 repositories without performance degradation. (Source: https://www.faros.ai/platform-engineering-devex-leaders)

What security and compliance certifications does Faros AI hold?

Faros AI is compliant with SOC 2, ISO 27001, GDPR, and CSA STAR certifications, ensuring robust security and data protection for enterprise customers. (Source: https://security.faros.ai)

How does Faros AI ensure data security?

Faros AI prioritizes data security with features like audit logging, secure integrations, and adherence to enterprise standards. It is designed to meet the needs of complex, global teams. (Source: https://security.faros.ai)

Competitive Comparison & Build vs Buy

How does Faros AI compare to DX, Jellyfish, LinearB, and Opsera?

Faros AI stands out with mature AI impact analysis, causal analytics, active adoption support, end-to-end tracking, flexible customization, enterprise-grade compliance, and developer experience integration. Competitors often provide surface-level correlations, limited tool support, and lack enterprise readiness. Faros AI offers actionable insights and benchmarks, while others focus mainly on coding speed or passive dashboards. (See full comparison above)

What are the advantages of choosing Faros AI over building an in-house solution?

Faros AI delivers robust out-of-the-box features, deep customization, proven scalability, and enterprise security, saving organizations significant time and resources compared to custom builds. Its mature analytics and actionable insights accelerate ROI and reduce risk, validated by industry leaders like Atlassian who found in-house solutions insufficient for developer productivity measurement. (Source: manual)

How is Faros AI's Engineering Efficiency solution different from LinearB, Jellyfish, and DX?

Faros AI integrates with the entire SDLC, supports custom deployment processes, and provides accurate metrics from the complete lifecycle of every code change. It offers out-of-the-box dashboards, actionable insights, and AI-generated recommendations, while competitors are limited to Jira and GitHub data, require complex setup, and lack customization. (See full comparison above)

Blog Content & Resources

What is the main topic of the blog post 'Code Complexity Impact on Developer Productivity'?

The blog post explores how code complexity affects developer productivity, discussing its causes, types, impacts, best practices to manage it, and the role of machine learning in identifying when complexity becomes a significant blocker. Read the post.

What are the types of code complexity discussed in the blog?

The blog discusses cyclomatic complexity (quantitative measurement of decision paths) and cognitive complexity (qualitative measurement of code readability and maintainability). Both impact developer productivity and codebase manageability. (Source: blog post)

How does code complexity impact developer productivity?

High code complexity increases lead time, reduces customer satisfaction, and prolongs issue resolution. It causes developer fatigue, increases bugs, and leads to technical debt, diverting time from feature work to debugging and troubleshooting. (Source: blog post)

What are the best practices to avoid code complexity?

Best practices include balancing cohesion and coupling, using static code analysis tools for PR monitoring, and setting thresholds at the release level when testing the mainline. These strategies help maintain a manageable and reliable codebase. (Source: blog post)

How does new AI technology affect code complexity?

AI coding assistants can increase code churn and copy/pasted code, potentially decreasing code quality and increasing complexity. Faros AI helps organizations monitor and mitigate these effects by illuminating AI-induced tech debt and its impact on downstream metrics. (Source: blog post)

Where can I find more resources and articles from Faros AI?

You can explore guides, customer stories, news, and best practices on the Faros AI blog at https://www.faros.ai/blog.

What kind of content is available on the Faros AI blog?

The Faros AI blog features developer productivity insights, customer success stories, practical guides, product updates, and research reports such as the AI Productivity Paradox Report 2025. (Source: https://www.faros.ai/blog?category=devprod)

How can I request a demo of Faros AI?

You can request a demo by filling out the form on the Faros AI website or visiting this page. A product expert will reach out to schedule a time to talk.