What I watched on a screen share with a Southern Arizona GC, what the industry data says about it, and what we are building live on September 10
Nate Kappler said that to me on a call last week, and I have not stopped thinking about it since.
Nate runs Kappcon Construction in Tucson. I had asked him to walk us through what actually happens when a punch list lands at a well-run GC, and to do it with real documents rather than a sanitized version. He said yes, opened his laptop, and shared his screen.
Before he opened Outlook he warned us there is a sign on the door that says abandon hope, all ye who enter. Every project manager reading this just nodded.
What followed was the most honest look at the mechanics of a real closeout I have seen in a long time. And it explained a specific number that shows up in every industry survey on the topic and never really makes sense until you watch it happen.
The last one percent of a job takes fifteen percent of your time.
What Actually Landed in the Inbox
The project was a recent public job. Here is what came in.
SOURCE | WHAT ARRIVED |
Architect | Day one. Roughly 28 items, organized by building and room. Clean structured text. |
Landscape architect | Same day, an hour earlier. Bullet points with red circles drawn on plan snippets and site photographs. |
Civil engineer | Same day, an hour later. Sidewalk repairs, documented across eight separate photo locations. |
Mechanical engineer | Seventeen days later. Three items. |
Four documents. Four firms. Two of them walked the same site an hour apart and did not coordinate. Forty-seven items in total, and not one of them says which subcontractor is responsible.
That is the part nobody outside the industry understands. The punch list tells you what is wrong. Figuring out whose problem it is falls entirely on the general contractor, and it lives in one person’s head.
The Item That Explains Everything
There was one item on that list that I want to sit with for a second, because it is the whole story in a single sentence.
“In mechanical yard gate, add mesh by gate to prevent someone reaching in, as agreed once elec. boxes moved.”
One item, from a real punch list
Read that as an outsider and you get almost nothing. Read it as Nate and you get all of it.
It is a fencing item, so it belongs to the fence contractor. But the electrician has to move his boxes first, so there is a sequence buried in the sentence. And on the vendor list for this project, the fence contractor appears as three letters that give no indication they build gates. Nothing about the code tells you anything about the trade or the company behind it.
It is not the only one. There is another vendor on that job whose name gives no indication they installed the aluminum storefronts. Nate knows because Nate was there.
Then it gets harder.
Two subcontractors on the project both list Framing and Drywall as their trades. When a drywall item comes through, there are two correct-looking answers. Two more list both Plumbing and HVAC. Same problem for the drinking fountains and the ADA shower valve.
Nine items are some version of clean this. Nate says anything that just says clean belongs to the GC, which means those route back to his own crew. Kappcon self-performed the sidewalks, so the entire civil punch list comes back to Kappcon too.
Forty-seven items. A vendor directory that reads like a puzzle. Ambiguities in half the trades. And exactly one person in the whole system who can look at any given item and know, from memory and from being there, whose problem it actually is.
That is why the number is fifteen percent.
This Isn’t a Kappcon Problem. It’s an Industry Problem.
Before I go further, I want to put some numbers on the table, because it is easy to read a story like that and think it’s an outlier.
It is not an outlier. Here is what the industry data says.
- 78 percent of general contractors cite punch list management as the single most time-consuming closeout activity, according to the AGC’s 2024 project closeout survey. Not one of the most. The single most.
- The median time from substantial completion to final payment on projects using manual punch list processes is 47 days, per Levelset’s 2025 construction payment report. Projects that have automated even parts of this process complete the same journey in 23 days. That is a 24-day gap between what manual closeout costs a firm and what a better process costs them.
- Punch list management consumes 12 to 18 percent of a project manager’s total time on commercial projects, per AGC. On a PM making $110K fully loaded, that is roughly $16,000 to $20,000 a year in salary spent on this coordination alone.
- The average GC loses $18,000 to $32,000 per project in delayed retainage from inefficient punch list management, per Levelset. On a 10-project year, that is a quarter million dollars sitting in a bank account that is not yours.
- And 66 percent of general contractors report having difficulty getting off the job on at least a quarter of their projects, per an Autodesk and Dodge study.
The reason those numbers are that consistent is that the mechanics are that consistent. Everybody has the same tools, the same subs, the same PDFs, the same coded vendor directories, the same one person carrying the whole assignment problem in their head. The industry has arrived at the same broken workflow through parallel evolution.
Which means the industry can arrive at a better one the same way.
The Part That Costs Money
The mechanics are frustrating. The economics are worse.
Punch list completion gates final payment. Nate put it plainly on the call: it is tied to final pay, it is tied to financial completion, everybody always says two weeks, and it is never two weeks. The owner has no particular motivation to accelerate the last check, and the crews who could actually close the items have already moved to the next job.
There is also a visibility problem underneath it. On this project, the earliest sign-off on the completed list was in late June and the latest was in early July. Ten days of real work getting done in the field. But until the whole list came back and got reconciled, the project effectively read as zero percent complete. Nobody could see progress. Nate described asking his team whether they had it, hearing yes we have it, and having no way to know.
That is the last one percent. And that is where the fifteen percent goes.
Why Your Software Isn’t Solving This
Kappcon runs Procore. They have it, the subs have access to it, and on this project they still worked the punch list on paper and uploaded a PDF at the end.
Nate was direct about why. The punch list tool carries what he called a heavy surcharge of setup. Somebody has to type every item in by hand and tag themselves on each one before the tool does anything useful. On a smaller job you could have just walked the painter out there and pointed at four spots. So teams take the faster path, which means the data never lands in the tool, which means you cannot analyze it later to see what keeps going wrong across your jobs.
This is not a Procore criticism. It is what happens to every good tool when the setup cost lands on the busiest person at the worst moment of the project. Which, if you have been reading these TechTips for a while, is a pattern we keep coming back to. The tech is not the bottleneck. It hasn’t been for a while.
What We’re Actually Building on September 10
Here is where the story takes a turn worth telling. Nate agreed to something that took real courage from a GC. He is letting us take his actual documents, put them in front of an audience, and build a working AI agent on them live.
That kind of yes takes real courage from a builder.
On September 10, at 11 AM Arizona, we are running Session 3 of our AI in Construction webinar series with Smartbuild, sponsored through the Arizona Builders Alliance. The session is called The Punch List Agent. It is the finale of Series One.
Nate is going to be in the room with us, with his real documents. The team from Smartbuild is going to build a Claude-based agent that reads the architect’s punch list, takes the project vendor directory as context, and assigns each item to the responsible trade. Where two subs could both own an item, it says so instead of guessing. Then it drafts the outreach to each sub.
Then we check it. Kappcon is providing the completed list showing who actually did each item, and we compare the agent’s assignments against it on screen.
Including the ones it gets wrong.
An agent that assigns thirty items cleanly and says “these seventeen need your eyes, and here is why” is more useful than one that claims to nail all forty-seven. The flagging is not a limitation we are apologizing for. It is the feature.
One Design Insight That Came From the Field
Nate’s project manager Tim, told us something on the call that changed the design.
When he distributes a punch list, he does not carve it into per-trade packets. He sends every subcontractor the complete list and tells them which pages matter most to their scope. His reasoning: if he overlooks an item or points a sub to the wrong section, that sub can still see the whole list and catch it.
That is a smart person building himself a safety net, and it is the kind of thing you only learn by asking the person who does the work.
So the agent does the sorting. And the sub still gets the whole list. The labor goes away. The safety net stays.
What This Doesn’t Fix (Yet)
I want to be honest about scope, because this piece is not selling anybody a silver bullet.
The agent we are building assigns and drafts. That is it. It does not push anything into Procore. It does not track completion or chase subs. It does not read the landscape and civil documents, where the real information lives inside red circles drawn on plan sheets rather than in the text.
That last one is a genuinely hard problem and we are not going to pretend otherwise on a live call.
Those are all real problems. They are all solvable. They are just not what we are building on September 10. We are focused on the piece of the workflow that most viscerally hurts, and we are building the version we can show working, end to end, in an hour.
You will leave the session with a much clearer sense of what agents like this actually do, what your firm needs to have in place to run one, and where the boundary sits between the parts AI handles well today and the parts that still need human judgment.
THE PUNCH LIST AGENT- SESSION 3 OF THE AI IN CONSTRUCTION SERIES
When: Thursday, September 10, 2026 at 11 AM Arizona
Featuring: Nate Kappler, President, Kappcon Construction
Live Build: A Claude-based Punch List Agent on real Kappcon documents
Hosted by: Dimensions and Smartbuild, sponsored through the Arizona Builders Alliance
Cost: Free. 60 minutes. Recording available to all registrants.
If you have ever stared at a punch list wondering which of your two drywall subs owns an item, or explained to an owner why the last one percent is taking three weeks, this one is for you.
Register Here: AI In Construction – The Punch List Agent
I spent an hour on a screen share with Nate and Tim and came away convinced this is the workflow AI was built for. On September 10, thanks to their willingness to put their real documents on the table, we are going to show you what that actually looks like in a room full of Arizona builders.
Bring your questions. And if your own closeout looks anything like this right now, come find me afterward.
I promise not to make you open your inbox.
For over 20 years, Dimensions has been the trusted IT partner for Arizona’s architecture, engineering, and construction industry. We help AEC firms communicate better, collaborate smarter, and actually use the technology they’ve invested in. Because in construction, the tools only work if your team does.
IT Built For Builders.
