Why manual CCTV coding is so error-prone (and what consistent coding takes)

Why two good inspectors can code the same pipe differently

Put two experienced, NASSCO-certified inspectors in front of the same length of footage. There’s a real chance they’ll code it differently. Not because either one is careless, but because manual defect coding, done at the volume real systems demand, is one of the harder judgment tasks in this industry, and it was never built to be perfectly repeatable.

That variability is where a surprising amount of downstream trouble starts. A capital plan, a rehab priority, a contractor’s invoice, an engineer’s recommendation: all of it sits on top of how a defect got coded. If the coding wanders, everything built on it wanders too.

So it’s worth being precise about why manual coding is error-prone, because the usual explanation, that someone needs to try harder or get more training, is mostly wrong. It isn’t a people problem. It’s a structural one. Naming the structure is the first step to fixing it.

The standard leaves room for judgment

PACP gives the industry a shared language, and that’s exactly why it works. It is a rigorous, detailed grading framework, and that precision is exactly why the industry relies on it. The variability does not come from a loose standard. It comes from the real world the standard gets applied in. But a standard still has to be interpreted by a human, and interpretation varies. Is that a crack or a fracture? A deposit or an obstruction? Where does a defect start and stop? Reasonable, well-trained people land in different places on the edge cases, and real pipe is full of edge cases.

What you can do: audit your own consistency. Pull a sample of footage already coded by two different crews and have them code each other’s segments blind. The gap you find is your real baseline, and most teams are surprised by it.

Volume and fatigue are real

A single project can run thousands of feet and hours of footage. Coding is close, repetitive, attention-heavy work. The hundredth joint of the day does not get the same fresh eyes as the first. That is not a knock on anyone. It’s what happens to any human doing high-volume detailed review for hours on end.

What you can do: treat fatigue as a workflow problem, not a discipline one. Anything that removes repetitive volume from a person is worth more than another reminder to focus.

Review is usually a sample, not a sweep

Most manual QA processes re-check a percentage of footage, because re-checking all of it by hand isn’t feasible. But that means the majority of coding decisions are never independently verified. Inconsistencies don’t slip through because anyone failed; they slip through because no one ever had the hours to look at every foot.

Consistency is one thing. Accuracy is another.

This is where AI changes the shape of the problem rather than just speeding up the old one, and it is worth being careful about what it does and does not do.

AutoCode applies the standard the same way across every foot, without fatigue and without the hundredth-joint problem. That consistency matters, because it removes the drift that creeps in between crews and across a long day. But consistency is not the same as correctness. A tool that is consistently wrong is still wrong, and any certified PACP professional will make that distinction instantly.

So accuracy has to be measured, not assumed. AutoCode's coded outputs have been independently audited against a manual baseline by a third-party engineering firm. That kind of outside measurement, not the fact that the coding is consistent, is what earns trust in the result.

What good actually looks like (and what NASSCO requires)

Here is the part that matters most, and the part the efficiency story usually gets wrong. AI does not remove the certified human from the loop. Under PACP, automated defect recognition is a supporting tool for the certified professional, who is required to review the deliverables before they are submitted. NASSCO does not certify the software. It certifies the person. That certified review is what makes a deliverable compliant, and it covers all of the data, not only the parts an algorithm flagged.

So the workflow that actually holds up looks like this: AI does a consistent first pass on every foot, and a PACP-certified professional reviews the coded deliverable before it goes out the door. The AI does not shrink that review to a handful of exceptions. It makes the full review faster and more focused, surfacing conditions and measurements so the certified reviewer can confirm a complete, consistent dataset instead of rebuilding it keystroke by keystroke. That is the role QAI plays: it lets a certified reviewer stand behind every foot, not just a sample of it.

Done that way, the data is both consistent and defensible. When the standard was applied the same way across the system and a certified professional signed off on the deliverable, a director can stand behind the priority list and a contractor can stand behind the invoice. The argument in the budget meeting shifts from do we trust this coding to what do we do about what it found.

What you can do: build the workflow as AI-accelerated and certified-human-reviewed. Let the system establish the consistent baseline on every foot, and keep a PACP-certified professional reviewing the deliverable before submittal. Faster review, not less of it.

The expertise was never the problem

Inconsistent coding was never a sign that the people doing it weren't good enough. It was a sign that we were asking humans to do, by hand and at scale, the one job that rewards machine consistency, while still needing human judgment and certified accountability on the result. Let the machine carry the repetitive baseline, keep the certified professional reviewing and standing behind the data, and the expertise that was always in the room finally gets pointed at the work that actually needs it.

Download the AutoCode Solution Brief