# Cycle Time Breakdown: Tactics for Reducing Coding Time | LinearB Blog

> This is the first installment of our Cycle Time Breakdown series on the most effective tactics to speed up your development cycle time. The other posts are: Tactics For Reducing Coding Time ← You are here Tactics For Reducing Pull Request Pickup Time Tactics For Reducing PR Review Time Tactics For Reducing Deploy Time In […]

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Cycle Time Breakdown: Tactics for Reducing Coding Time",
      "item": "https://linearb.io/blog/reducing-coding-time"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

Cycle Time Breakdown: Tactics for Reducing Coding Time

# Cycle Time Breakdown: Tactics for Reducing Coding Time

![Photo of Nick Hodges](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0)

By [Nick Hodges](https://linearb.io/blog/reducing-coding-time#nick-hodges)

|

July 16, 2021

![coding_time_d1844215c2](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/coding_time_d1844215c2?_a=BAVMn6ID0)

This is the first installment of our Cycle Time Breakdown series on the most effective tactics to speed up your development cycle time. The other posts are:

* Tactics For Reducing Coding Time ← You are here
* [Tactics For Reducing Pull Request Pickup Time](https://linearb.io/blog/pull-request-pickup-time)
* [Tactics For Reducing PR Review Time](https://linearb.io/blog/reducing-pr-review-time)
* [Tactics For Reducing Deploy Time](https://linearb.io/blog/cycle-time-breakdown-tactics-for-reducing-deploy-time)

In this piece, we’ll look at the first part of a development cycle: Coding Time.

It’s an issue we’ve all encountered, whether as an individual contributor or an [engineering manager](https://linearb.io/blog/software-engineering-management): It’s taking too long to write code. Until the code is written, it can’t be reviewed, iterated upon, and merged into production. 

In this post, we’re going to look at actionable tactics you can use to reduce coding time and speed up your overall Cycle Time. In future posts, we’ll look at how to reduce [Pull Request Pickup Time](https://linearb.io/blog/pull-request-pickup-time) and [Pull Request Review Time](https://linearb.io/blog/reducing-pr-review-time).

## Table of Contents

* [What is Coding Time?](#what)
* [What’s the Cause of High Coding Time?](#cause)
* [Investigating high Coding Time With LinearB](#investigating)
* [Preventing high Coding Time](#preventing)
* [Conclusion](#conclusion)

## What is Coding Time? 

[Cycle time is the dev manager’s super metric](https://linearb.io/blog/cycle-time). So naturally, the conscientious dev manager will want to pay close attention to coding time, the very first segment of a project’s journey along the cycle time path. 

**Coding time is defined as the time between the first commit made to a branch to when a pull request is submitted.** LinearB analyzed data from almost 2,000 teams and over 847,000 branches to establish [benchmarks for key engineering metrics](https://linearb.io/engineering-benchmarks), including coding time. 

![Engineering benchmarks chart](https://assets.linearb.io/uploads/benchmarks-chart-1024x670.png)

Want to learn more about being an elite engineering team? [Check out this blog](https://linearb.io/blog/engineering-metrics-benchmarks-what-makes-elite-teams) detailing our engineering benchmarks study and methodology.

For the purposes of this post, we’re most interested in the coding time row. Elite teams spend less than 12 hours coding. In practice, this means that whatever they start, they finish by end of day. To be honest, this a remarkable feat. 

Most teams take between 12 and 38, which accords with my experiences. Anything over 39 (so anything over about 2 full days) is cause for concern. 

In the past, we could measure the notion of coding time only anecdotally. Perhaps you could keep track of how the coding on a project was going by the reports in a daily standup. 

However, these days, engineering leads are increasingly data-driven. LinearB is making it possible to track Coding Time. By integrating with Git and project management tools, like GitHub, GitLab, and Jira, we can create specific and easy-to-read cycle time breakdowns for all your projects. 

Linearb’s cycle time chart breaks down cycle time into its 4 components.

In this example, you can see that coding time is turning red. This means it needs focus. Pickup time is orange, so it could be improved as well. Review time and Deploy time are green and healthy. 

In a glance, you can see where there is room for improvement and start taking action to remove bottlenecks and improve cycle time. LinearB automatically tracks any changes, updating the chart in real-time, so you can see instantly whether your efforts are paying off. With our [free plan](https://linearb.io/pricing), getting started is not only easy, but it’s free!

[![Measure Your Team's Cycle Time in Minutes. Break down your team’s cycle time in 4 phases for bottleneck detection in seconds. Get context in one click and dive into any of your cycle time metrics to discover which branch is behind the spike. Diving into your data has never been this easy!](https://assets.linearb.io/uploads/cycle-time-cta-block-1-1024x497.png)](https://linearb.io/get-started)

## What’s the Cause of High Coding Time?

Now that we understand the importance of coding time, and the importance of measuring it precisely, let’s look at why high coding time arises in the first place.

There are three main causes:

1. The task is too large
2. The task is too difficult
3. The task is languishing

### 1\. The task is too large

This is probably the most common reason that devs spend too much time coding up one particular task: The task is simply too big to complete in one delta. In other words, the developer bit off more than they can chew.

**Commit small, commit often.** This is the mantra of modern software engineering teams, especially those working on web apps in a CI/CD paradigm. It is better to have many smaller deltas that are precisely scoped than one large delta that contains many changes. 

Another benefit of smaller deltas is that they get reviewed faster. This may sound like a small point, but based on our analysis of all those dev teams and their projects, [long review times slow down cycle times to a shocking degree](https://linearb.io/blog/the-pull-request-paradox-merge-faster-by-promoting-your-pr). 

That’s why one of Slack’s core metrics is PR review time, which Slack’s VP of Engineering, Rukmini Reddy, revealed on the Dev Interrupted podcast:

### 2\. The task is too difficult

Sometimes, a task can turn out to be harder than anticipated. Maybe the problem wasn’t completely understood. [Or perhaps there were a number of “unknown unknowns” that were discovered, making the project bigger than anticipated](https://devinterrupted.com/nine-software-development-lessons/). Unexpected difficulty will increase the total time it takes code up a task.

A second order effect of unforeseen challenges is that time management becomes a nightmare. How can you plan ahead if you don’t know how long the work is going to take? 

The problem is compounded in a team setting, where you need to allocate work among team members. Managing projects and tasks is already difficult enough before you’re forced to reallocate resources on the fly while still keeping an equitable distribution of work hours. 

### 3\. The task is languishing

This one is pretty simple: coding time is taking longer than expected because the task was started but then dropped for a length of time. Most likely the developer was required to turn to other tasks based on new priorities.

## Investigating High Coding Time with LinearB

The first thing to do about high coding time is to find out which projects or branches are the ones causing the problem. In order to do that, you can drill down into the LinearB dashboard and take a look. 

To look more deeply, you can click on the little arrow in the upper right corner of the cycle time Box.

![Image shows the arrow to click on that drills down to the branches view](https://assets.linearb.io/uploads/image5.gif)

Doing that will take you to the Branch View of your repository. From there, you can see all the branches that are affecting your coding time. 

For instance, the top branch below had a coding time of almost eight days – a really long time!

![You can display the Cycle Time breakdown for any branch in the Branch View](https://assets.linearb.io/uploads/image1.gif)

Note, too, that you can see the exact contribution that any branch is making to the overall cycle time by simply hovering your mouse over the cycle time column of the given branch. 

This granular level of detail allows you to see which projects and branches have high Coding Times so that you can start taking targeted action and making improvements. 

Once a branch has been determined to have a coding time problem, you drill down on that branch to diagnosis the root cause and then work with your team to remedy the situation.

## Preventing High Coding Time

Naturally, what you really want as a manager is to prevent coding time from being a problem in the first place. 

The first thing you can do towards that goal is to educate your team on the need for dividing your work into small, manageable chunks. This will improve coding time and have positive cascading effects downstream on pull request times, as mentioned above. 

**The rule of thumb is to have fewer than 150 changes in a delta.**

LinearB can help your team accomplish this goal with our configurable [Team Goals and WorkerB notifications](https://linearb.io/workflow-optimization). They alert you when a pull request exceeds a certain number of code changes, a number that you can set. This not only informs you of a delta that potentially had a high coding time, but it also enables you to intervene right away and start to drive improvement in this dimension. 

![You can adjust when you are notified about Work at Risk](https://assets.linearb.io/uploads/image6.png)

Another way to keep an eye on coding time is to [create a custom dashboard with PR size and coding time. ](https://linearb.io/blog/custom-metrics-dashboards)

![You can build a dashboard to keep an eye on Coding Time issues](https://assets.linearb.io/uploads/image4.png)

## Start Reducing Cycle Time Today

Keeping coding time, and thus cycle time, under control is a critical means to continuously improving your software development process. By keeping an eye on individual branches where coding time is pressing up against your limits, and by warning your team about branches not meeting your team goals, you can ensure that your coding time stays under control. 

These are just some of the many benefits of LinearB. To learn about all our advanced features and all the ways you can improve your development processes with LinearB, get in touch with us to [book a demo](https://linearb.io/get-started).

But don’t just take our word for it.

[![How Dama Financial Improved Cycle Time with LinearB](https://assets.linearb.io/uploads/LinearB-Youtube-Card_-Zach-Goldberg-How-Dama-Financial-Improved-Cycle-Time-With-LinearB-1024x576.png)](https://linearb.io/blog/how-dama-financial-improved-cycle-time-with-linearb)

Want to learn more about improving your cycle time? [Check out how our customer Dama Financial reduced their cycle time.](https://linearb.io/blog/how-dama-financial-improved-cycle-time-with-linearb)

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

## Your next read

[![Cover image for You can now measure AI ROI with LinearB](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_1_dd1f47bae7?_a=BAVMn6ID0)](https://linearb.io/blog/ai-roi-dashboard)

Product

[You can now measure AI ROI with LinearB](https://linearb.io/blog/ai-roi-dashboard)

Today, we're launching the AI ROI dashboard in LinearB, live now for every customer with metrics builder enabled.

[![Cover image for AI ROI comes from measuring engineering outcomes on day one](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_ROI_comes_from_measuring_engineering_software_security_2400x1256_2c5eae0862?_a=BAVMn6ID0)](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Product

[AI ROI comes from measuring engineering outcomes on day one](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Kraken Engineering Operations Lead Nik Sudan details how to establish day-one data infrastructure to accurately measure AI ROI. Discover why raw token adoption...

[![Cover image for Best Appfire Flow alternatives in 2026](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Moving_beyond_flow_88c071e703?_a=BAVMn6ID0)](https://linearb.io/blog/flow-alternatives-2026)

Product

[Best Appfire Flow alternatives in 2026](https://linearb.io/blog/flow-alternatives-2026)

Flow provides DORA metrics, workflow diagnostics, and useful dashboards for engineering leadership. But it has real limitations, and the market has moved...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Cycle Time Breakdown: Tactics for Reducing Coding Time",
  "url": "https://linearb.io/blog/reducing-coding-time",
  "author": {
    "@type": "Person",
    "name": "Nick Hodges"
  },
  "datePublished": "2021-07-16T12:12:57.000Z",
  "dateModified": "2021-07-16T12:12:57.000Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/coding_time_d1844215c2.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "This is the first installment of our Cycle Time Breakdown series on the most effective tactics to speed up your development cycle time. The other posts are: Tactics For Reducing Coding Time ← You are here Tactics For Reducing Pull Request Pickup Time Tactics For Reducing PR Review Time Tactics For Reducing Deploy Time In […]\n"
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/resources/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)