What Is AI Slop? The Engineering Leader's Guide to AI Waste in Software Delivery

All Posts
Share this post
Share this post

TL;DR: AI slop is work or output that consumes tokens or human time without contributing to delivered value. In software, that includes tokens spent on discarded agent code, review time on oversized pull requests, time spent steering agents, and rework that displaces committed work. Its costs show up in three operational outcomes: quality shows defects, efficiency shows lost time, and predictability shows missed commitments. minware regresses roadmap value delivery against token spend with these outcomes as guardrails, while best practice metrics such as PR complexity and pre-merge churn rate help teams investigate the root causes.

The word "slop" rose to prominence to describe low-quality AI-generated content flooding social media and search results. Merriam-Webster named "slop" its 2025 Word of the Year, defining it as "digital content of low quality that is produced usually in quantity by means of artificial intelligence." In software engineering, the problem is broader and quieter. It covers any tokens or human time spent on work that never turns into delivered value, from discarded agent code to review time on oversized pull requests.

This guide defines AI slop in engineering terms and shows where AI-generated code creates it. It then covers the operational outcomes that show its costs, how to connect them to token spend, and how teams trace a slipping outcome back to its root causes.

Defining AI slop in engineering terms

AI slop is waste in software delivery. It costs tokens and human time across the whole life of a change, from the first agent session to the rework that follows.

Separating AI slop from technical debt

minware's Lean AI Framework defines AI slop as work or output that consumes tokens or human time without contributing to delivered value. Low-quality code is the most visible source of it. The slop is the waste around that code: the tokens that produced it, the review time it takes, and the rework it causes later.

A 2026 study of 302,600 AI-authored commits across 6,299 public GitHub repositories found that minor issues such as broad exception handling and unused variables can accumulate into a substantial maintenance burden over time.

Traditional technical debt is often a deliberate, localized shortcut the team knows about. AI slop is waste in tokens and human time. Much of it never appears in the codebase at all. The table below is a working framework for telling them apart, drawn from practitioner reporting and minware's Lean AI Framework.

Characteristic Healthy code Technical debt AI slop
Definition Code meeting functional and maintainability requirements Shortcuts taken deliberately to ship faster, with costs deferred Work or output that consumes tokens or human time without contributing to delivered value
Primary signal Stable bug rate and churn rates Localized complexity and accumulated workarounds Token spend rising without a matching rise in roadmap value delivery, with best practice metrics such as post-merge churn rate above 15% for a developer-week as the cue to investigate, per minware's Lean AI Framework
Detection method Standard code review Team knowledge and architecture review Regressions of roadmap value delivery and overhead cost against token spend. Operational outcomes act as guardrails, with best practice metrics used to investigate root causes
Remediation Standard refactoring Planned refactoring Team-specific action items from a root cause review of the pull requests, tickets, or sessions behind a slipping metric

Mapping the sources of slop

Each best practice metric in the Lean AI Framework targets a main source of slop. Many of those sources are tokens or human time spent outside the code itself. The table below covers the ones this guide uses to diagnose slop, and the framework has others.

Slop Metric Starting point
Human context switching Ticket work in progress (WIP) A target of 1.5 or below
Wasted tokens on underspecified functionality Ticket size Break down any ticket worth a week or more of one person's time
Human review time on avoidable complexity PR complexity Review pull requests above 500 added lines
Wasted tokens on discarded code Pre-merge churn rate Pull requests above 50%, with an average below 30%
Wasted tokens on short-lived code Post-merge churn rate Developer-week data points above 15%
Human time waiting for agents Agent session length The 10 to 20 longest sessions each week
Human time babysitting agents Human intervention rate The most common intervention types first

These are best practice metrics. Teams use them to investigate the root causes of problems in their operational outcomes. They aren't goals for leadership to judge performance by. minware doesn't recommend regressing them against token spend, since the direction of cause is hard to read.

Distinguishing engineering slop from the meme

Outside engineering, "slop" describes low-effort AI-generated images and text flooding social platforms. That content is usually obvious at a glance. AI slop in software is harder to see. Much of it is tokens and human time that never appear in a diff, while the code that does ship passes the happy-path tests. The waste starts before merge, in tokens spent on work that needs redoing and time spent babysitting agents. After merge, rework costs more time and tokens. The work it displaces puts sprint and project commitments at risk.

Engineering leaders can't rely on visual inspection or gut feel to find it. A 2026 qualitative study of 1,154 developer posts on Reddit and Hacker News found developers describing who carries that hidden cost: each AI-generated submission that skips quality review externalizes its costs onto reviewers.

Linking code volume to review strain

AI coding tools raise the volume of code arriving for review faster than review capacity grows. Salesforce engineering reported that code volume increased by approximately 30%, while review time for the largest pull requests began to plateau or even decline. The team read this as a sign that reviewers were no longer meaningfully engaging with changes.

An agent can produce a multi-file change in minutes, while a careful human review of the same change can take hours. Once that gap opens, review covers a shrinking share of what ships. The pattern is easiest to see on the largest pull requests, where review time should grow with the size of the change. This is one form of AI slop. It wastes review time now, along with the tokens spent producing more code than the change needed. Later come the bug fixes, the refactoring of unwieldy code, and the opportunity cost of the work the team meant to do.

Spotting where AI-generated code creates waste

AI-generated code counts as slop only when it wastes tokens or human time, either in producing it or later in review and rework. The sections below show where that waste builds up.

Checking what AI-generated tests verify

AI-generated tests often confirm that code runs without checking that its output is correct. A test that repeats the implementation's assumptions ends up confirming wrong behavior. SpecStory's worked checkout example shows the pattern: an agent-written test passes whether the cart is intact or empty, because it checks only that setAddress returned something.

The waste comes on both sides of merge. Tokens go into tests that check nothing useful, and reviewers spend time on a green suite that proves little. The bug the test should have caught surfaces later as rework, which costs more time and tokens than catching it before merge. Those bugs show up in bug rate, and the rewrites show up in post-merge churn rate.

Spotting padding in agent changes

Padding makes bugs in AI-generated code harder to find by reading. In the same SpecStory example, the reviewer has to read past a copied address check and an unused class to reach the changed line that empties the cart.

Developers feel this cost directly. In the 2025 Stack Overflow Developer Survey, 66% of developers cited "AI solutions that are almost right, but not quite" as a frustration, the most common answer. Almost-right code is what padding hides: the change looks complete, so the one wrong line gets less attention. Smaller, single-purpose pull requests reduce the problem, because each change has less padding to read past. PR complexity shows where to start. minware recommends listing pull requests above 500 added lines, then having a senior engineer check whether each one needed that length or should have been split. The threshold catches padded agent output along with every other cause of oversized pull requests.

Tracking the maintenance cost over time

AI-generated code bloat is unnecessary code volume that increases maintenance burden without adding functionality. The bloat compounds. At first the debt is mostly invisible: tests pass, features ship, and delivery looks healthy. Over time the accumulated duplication, missing abstractions, and security gaps start to slow development.

A 2026 arXiv study of AI-authored commits found that 22.7% of tracked AI-introduced issues still survive at the latest version of the repository. Comprehension adds to the cost. In the 2025 Stack Overflow Developer Survey, 16.3% of developers said it is hard to understand how or why AI-generated code works, and code nobody fully understands takes longer to change safely.

Measuring the three costs of AI slop

AI slop costs a team in three ways, and the Lean AI Framework's operational outcomes show each one. Quality metrics show defects, efficiency metrics show lost time, and predictability shows missed commitments. Each outcome below comes with a short diagnostic path, the best practice metrics to check first when it moves. A path is a place to start looking, and it covers only the most common sources. Reviewing the flagged pull requests, tickets, or sessions confirms whether a metric on the path explains the change.

Leading with bug rate

Bug rate is the quality metric to lead with. minware calculates it as bugs created divided by pull requests merged into a main branch. It captures quality problems that reach the backlog whether or not they caused a production incident, which makes it a superset of change failure rate. If AI slop is accumulating, bug rate rises, because each merged pull request produces more bugs than before.

Bug lead time, the time from when a bug is reported to when it is fixed, adds a second view. A rising bug lead time suggests the code is getting harder to work with, which is the maintainability cost AI slop carries. Read together, the two show whether defects are increasing and whether each one is taking longer to resolve.

Reading change failure rate in context

DORA defines change failure rate (CFR) as the ratio of deployments that require immediate intervention, such as a rollback or hotfix. DORA's 2024 State of DevOps report puts the elite change failure rate at 5%. The benchmark uses DORA's deployment-based definition, so it only applies to a deployment-based change failure rate. A sustained rise above your own historical baseline is the more useful signal for AI slop, since it suggests code is passing review but failing in production.

CFR only catches failures severe enough to need immediate remediation. In 2024, DORA researchers found that change failure rate acted as a proxy for the amount of rework a team performs, which led to a fifth metric: deployment rework rate. By default, minware's pre-built DORA reports calculate change failure rate from bug tickets and pull requests, as highest-priority bugs divided by pull requests merged. Customers can switch the denominator to deployment data from Git tags or CI/CD runs to match DORA's definition.

When bug rate, bug lead time, or change failure rate rises, start with PR complexity, since larger pull requests carry more risk of bugs. Ticket size comes next, because oversized tickets leave room for missing requirements. Post-merge churn rate is worth reading alongside them, since it shows code quality problems that escaped review without turning into bug tickets.

Tracking lost time with efficiency metrics

Much of the slop mapped earlier is human time: review burden, agent steering, and context switching. Each one lengthens the time work takes to finish, and minware's two efficiency metrics show where that time lands. PR lead time runs from a pull request's first commit to deployment, which defaults to merge into a main branch. minware breaks it down by stage, which shows how much of that time goes to code review. Ticket cycle time runs from when a ticket moves to in progress until it is done, and it catches delays outside the pull request, such as waiting on other people or switching between tasks.

When PR lead time stretches, start with PR complexity, since larger pull requests take disproportionately longer to review. Human intervention rate and agent session length come next, because they show time spent steering agents or waiting on them. When ticket cycle time stretches, start with PR complexity, ticket WIP, and pre-merge churn rate.

Catching missed commitments with sprint completion

Slop also costs predictability. When AI-generated code ships bugs, the fixes arrive as unplanned work that displaces what the team committed to. Sprint completion shows this cost. minware calculates it as story points completed each sprint divided by story points in the original commitment, capped at 100% per sprint. It is an earlier leading indicator of on-time delivery rate, so a drop shows up while there is still time to correct course before a roadmap item is late.

When sprint completion falls, start with ticket WIP and ticket size. A high ticket WIP points to interruptions from bugs or urgent unplanned work, while oversized tickets hide missing requirements that surface mid-sprint. Teams not running sprints can use ticket or story point completion against a fixed weekly commitment instead.

Tracking pre-merge and post-merge churn

minware's Lean AI Framework splits churn into two named metrics. Post-merge churn rate is the share of merged code lines removed within 14 days of merge, weighted by line count. The framework suggests drilling into developer-week data points above 15%. Pre-merge churn rate is the share of lines added that never make the final merge, and the framework suggests focusing on pull requests above 50% churn while keeping the average below 30%.

The two catch different problems. Pre-merge churn points to planning and prompting problems, where an agent writes code that gets thrown away before merge. Post-merge churn points to quality problems that escaped review. Both are best practice metrics, which makes them diagnostics. Teams use them to investigate the root causes of a slipping outcome by finding the specific pull requests behind a rise. Some churn is healthy, so the team's own read of the flagged pull requests matters more than the number alone.

Watching PR complexity

Pull requests merged is a throughput metric that minware doesn't recommend tracking. It counts code output without showing whether that output delivered value, which makes it misleading. It is also easy to game in either direction.

PR complexity is the better place to look, since it shows review time spent on avoidable complexity. It measures the number of added code lines in a pull request by default, as a proxy for review risk and effort. minware recommends starting with a 500-line threshold, then adjusting it up or down depending on how many flagged pull requests turn out to have a real issue. For each one, a senior engineer asks whether it could and should have been split up.

Reading the metric set together

The table below ties the main metrics in this section to the cost of slop each one shows, with token spend added for context.

Metric Cost of slop What it measures Warning signal Read alongside
Bug rate Defects Bugs created divided by pull requests merged Sustained rise as token spend rises Bug lead time
Bug lead time Defects that are hard to fix Time from when a bug is reported to when it is fixed Sustained rise as token spend rises Bug rate
Change failure rate Severe defects Highest-priority bugs divided by pull requests merged, by default Sustained rise above your historical baseline Deployment frequency, under the deployments-based configuration
PR lead time Time lost to review burden and agent steering Time from first commit to deployment, by default merge into a main branch Lengthening as token spend rises PR complexity
Ticket cycle time Time lost to waiting and context switching Time from when a ticket moves to in progress until it is done Lengthening as token spend rises Roadmap value delivery
Sprint completion Missed commitments Story points completed divided by story points committed, capped at 100% per sprint Falling as token spend rises On-time delivery rate
Post-merge churn rate Wasted tokens on short-lived code Merged lines removed within 14 days, divided by total lines merged Developer-week data points above 15% Bug rate
Pre-merge churn rate Wasted tokens on discarded code Lines added that never make the final merge, divided by total lines Pull requests above 50%, or an average above 30% PR complexity
PR complexity Human review time on avoidable complexity Added code lines per pull request, by default Pull requests above 500 added lines, as a starting threshold PR lead time
Token spend Context: what AI costs Dollar cost of AI tool usage Rising without a corresponding change in delivery outcomes Roadmap value delivery, on-time delivery rate

Token spend shows what AI costs. The outcome metrics show what slop costs: defects for quality, time for efficiency, and missed commitments for predictability. A team can ship quickly and avoid production failures while still rewriting a large amount of recently merged code, which is why post-merge churn rate belongs next to change failure rate.

Connecting token spend to delivery and operational outcomes

The operational outcomes show whether AI slop is costing defects, time, or missed commitments. Connecting them to token spend shows whether those costs move with AI spend.

Regressing bug rate against token spend

Connecting token spend to quality by hand means building a custom data pipeline across your version control system (such as GitHub, GitLab, Bitbucket, or Azure DevOps), your project management system (such as Jira, Linear, Azure Boards, or GitHub Issues), and AI tool data. For AI return on investment (ROI) analysis, minware normalizes data from those sources, plus CI/CD, into a single layer. Our AI impact reporting regresses quality outcomes against token spend, including bug rate, and its example chart plots bugs created against token spend.

minware's Lean AI Framework adds separate regressions of roadmap value delivery, on-time delivery rate, and overhead cost against token spend.

The slope is the outcome change per additional dollar of token spend. R-squared is the share of the outcome's variation that spend explains, on a 0-to-1 scale. minware's regressions group by team and time period by default. Both variables are normalized per person-day so team size doesn't distort the slope. For quality, the bug rate regression is the one to watch: a positive slope means team-periods with higher token spend show a higher bug rate. The same regression applies to PR lead time, ticket cycle time, and sprint completion, which show whether higher spend coincides with lost time or missed commitments. Reported token spend can differ from the amount actually invoiced on flat-rate or discounted plans.

Controlling for selection bias

A regression shows correlation, so name the confounders before drawing a conclusion from it. Engineers tend to reach for AI on work where it is likely to help, which is task-level selection. Early adopters are often already the strongest performers, which is person-level selection. Code base age and existing code quality also shift both variables.

minware's Lean AI Framework uses continuous token spend as the input variable in place of an AI versus non-AI split. Non-AI groups are disappearing as adoption spreads, and the ones that remain are prone to selection bias, so comparing AI users with non-users no longer holds up. The supporting check is each team's own trend over time as token spend changes.

Configuring data collection early

Detecting AI slop with token spend regressions doesn't need a clean pre-AI baseline. What matters is connecting AI tool data as soon as possible, so usage is captured from that point forward. OpenTelemetry has no historical backfill, which makes early configuration the priority. Claude Code's Analytics API can backfill usage for Console organizations at a coarser per-user, per-model, per-day grain.

Because minware recovers the relationships between agent sessions, commits, and tickets, analysis can start before source data is cleaned up. It does this by modeling what commit and ticket each person was working on at any given time. This relationship recovery is part of minware's patented hypercube data model, alongside identity resolution across systems and data normalization of each vendor's format.

Pairing guardrails to prevent gaming

Once a metric carries weight in reporting, it invites gaming. The operational outcomes act as guardrails on the business outcomes, so a rise in roadmap value delivery that comes at quality's expense shows up in bug rate and change failure rate.

For delivery impact itself, name the value delivery metric first. Roadmap value delivery and on-time delivery rate answer whether delivery improved. Bug rate, change failure rate, PR lead time, ticket cycle time, and sprint completion explain why a trend is moving. The manager always holds final judgment over what the metrics show, which removes most of the incentive to game a single number.

Tracing slipping outcomes to root causes

When an operational outcome slips, the diagnostic paths above show which best practice metrics to check first. The best practice metric that is off points to where the waste is coming from. From there, minware lists the specific pull requests, tickets, or agent sessions driving that metric, each linked back to its source system.

The team then reviews those items to find the root causes and decide on action items. Those action items are specific to each team, since the same metric can slip for different reasons on different teams. After the changes land, the operational outcomes and the token spend regressions show whether they worked.

Turning AI slop into a measurable signal

AI slop is waste: tokens and human time that never turn into delivered value. It shows up as operational outcomes struggle. Regressing roadmap value delivery and overhead cost against token spend shows whether rising AI spend is buying delivery. Bug rate and change failure rate show whether quality is slipping. PR lead time and ticket cycle time show lost time, while sprint completion shows missed commitments. Best practice metrics such as pre-merge churn rate, PR complexity, and human intervention rate point to the specific sources behind it. Together they give an engineering leader the answer the next exec review needs.

Start a 14-day free trial at minware.com, no credit card required. Connect your version control, project management, and AI tool data. Then see roadmap value delivery and bug rate regressed against token spend for your own teams, with the slope and R-squared value on each chart.

FAQs

How is AI slop different from technical debt?

AI slop is work or output that consumes tokens or human time without contributing to delivered value. Traditional technical debt is usually a deliberate shortcut that is localized and known to the team. Much of AI slop never appears in the codebase, so it surfaces in operational outcomes such as PR lead time and sprint completion.

What metrics reveal quality problems stemming from increased AI usage?

Bug rate, change failure rate, and bug lead time are the quality outcomes to watch, with bug rate as the lead metric. Regressing bug rate against token spend shows whether team-periods with higher spend also show more bugs. Post-merge churn rate adds code quality problems that escaped review without becoming bug tickets. When these rise, PR complexity, ticket size, and pre-merge churn rate are the first places to look.

How does minware detect AI slop?

minware detects AI slop through metrics. It regresses roadmap value delivery against token spend, along with overhead cost, grouped by team and time period. Operational outcomes act as guardrails, such as bug rate for quality, PR lead time for efficiency, and sprint completion for predictability. Each chart shows the slope and R-squared value. Best practice metrics such as pre-merge churn rate, PR complexity, and human intervention rate then point to specific sources of slop, with lists of the pull requests or sessions to investigate. minware doesn't scan code for slop patterns, which is a job for code analysis tools. Every calculation is visible and editable in minQL, minware's formula language.

Is AI slop just a craft vs. product debate?

No. The top comment in one Hacker News thread split developers into two camps: those who treat code as a craft, and those who treat it as a means to a product. Many replies rejected that split, arguing that code quality shows up in reliability and maintainability. Measurement puts numbers on that tradeoff, so a team can decide how much churn it accepts in exchange for speed.

Key terms glossary

Agent session length: The duration of an agent session, measured directly from its start and end times in AI tool session data.

AI slop: Work or output that consumes tokens or human time without contributing to delivered value. The Lean AI Framework's term for waste, covering tokens spent on discarded agent code, review time on low-quality pull requests, human time spent steering agents, and the rework that follows defects reaching production.

Bug lead time: The time from when a bug was reported to when it was fixed. By default, calculated as the time from ticket creation to ticket resolution for all bug tickets.

Bug rate: A quality metric measuring the number of bugs created divided by the number of code changes, by default the number of pull requests merged into a main branch.

Change failure rate (CFR): By default, minware defines change failure rate as the number of highest-priority bugs divided by the number of pull requests merged to a main branch. Customers may reconfigure the denominator to production deployments, from Git tags or CI/CD pipeline runs, to align with DORA's own definition: the number of change failures divided by the number of deployments.

Human intervention rate: The count of permission escalations and other prompts in between instructional prompts, divided by the number of instructional prompts in an agent session.

Linear regression: A statistical model charting the best-fit line between an outcome metric and an input variable. Each regression fits one metric pair, so correlating spend against multiple outcomes requires a separate regression for each.

On-time delivery rate: The estimated roadmap item duration (time from when a roadmap item is marked in progress until the original due date set at that time) divided by the actual roadmap item duration (time from in progress until it is marked done), capped at 100% per roadmap item. By default, minware treats each epic as a roadmap item, and this can be configured to use higher-level tickets instead.

Overhead cost: Personnel cost and AI token spend that goes toward work not counted in roadmap value delivery, i.e. cost not traceable to any ticket, or traceable to a ticket excluded from roadmap value delivery (by default, a bug ticket or a ticket with no parent epic/project ticket).

Post-merge churn rate: For each pull request merged into a main branch, the number of merged code lines removed within 14 days divided by the total lines merged, recorded at the end of the 14-day window. Weighted by line count, so larger pull requests count for more.

Pre-merge churn rate: The total lines added that don't make it to the final merge across all commits in a pull request, divided by the total lines including both churned and merged lines.

PR complexity: The risk and review effort associated with a pull request, measured by default as the number of added code lines.

PR lead time: The time from a pull request's first commit to when it was deployed. Deployment defaults to when the code merges into a main branch, and can be configured to use Git tags or CI/CD deployment pipeline runs.

Pull requests merged: The total number of pull requests merged, to or from any branch.

R-squared: In a regression chart, the share of the outcome metric's variation explained by the input variable, on a 0-to-1 scale.

Regression slope: The change in an outcome metric per unit change in the input variable, such as roadmap value delivery per dollar of token spend.

Roadmap value delivery: The expected value of completed work items. Configurable to any project management field where a team sets explicit value estimates during roadmap planning, or to a custom spreadsheet upload. If no explicit value field is configured, defaults to story points completed on tickets that are not bugs and have a parent epic/project ticket, with 1 point assigned per ticket if no estimate is set.

Sprint completion: The total story points completed each sprint divided by the story points in the original commitment, capped at 100% per sprint. Late additions to the sprint are not penalized. A predictability metric and an earlier leading indicator of on-time delivery rate.

Ticket cycle time: The time from when a ticket was first marked in progress to when it was completed.

Ticket size: By default, a ticket's story point estimate. Any single ticket representing a week or more of one person's capacity should be broken down.

Ticket work in progress (WIP): The total time during a day that a ticket is in progress and assigned to a person, divided by a day. minware recommends 1.5 as a realistic target.

Token spend: The dollar cost of AI tool usage, as reported by AI tool APIs or OpenTelemetry. On flat-rate, tiered, or discounted plans, reported spend may differ from the amount actually invoiced.