Last time I said the design walks into the room and the sheets pay for it. This is part two, and it's about the first thing on the sheet to break: the match lines.
First, what a match line actually is, because the tool quietly narrows the definition and it's worth catching. A match line is the marker at the edge of a tiled plan that tells the reader where the drawing continues, the see sheet note at the seam. By that definition it belongs on nearly every drawing in a set. Any plan too big for one sheet gets tiled and needs them: site plans, utility plans, grading plans, paving plans. The only sheets without them are the ones that stand alone and continue nowhere, the details and the sections.
But Civil 3D only builds match line objects one way: along an alignment, through Plan Production's view frames. On a tiled plan that isn't driven by an alignment, the tool won't place a match line at all, so you draw and label them by hand. That's worth sitting with, because it means the native match line is the narrow case, not the general one. This post is about that narrow case, the alignment-driven plans, and what happens to their match lines when the alignment moves. The next post is about everything else: when the geometry holds still and the scope moves, the set renumbers, and every match line in the set, alignment-driven or hand-drawn, has to be reconciled. Two triggers, two kinds of pain. This is the first.
When the alignment moves, the match lines are the first thing to lie to you. The seam that used to fall cleanly between sheet 4 and sheet 5 now falls somewhere in the middle of sheet 4, and the little label still says see sheet 5, and it's wrong, and it stays wrong until someone notices. The viewport behind it still shows the old extent. The plan that ended at the match line now runs past it. None of it agrees with the geometry anymore, and the geometry is the only thing that's actually true.
This is the failure I find people apologize for most, because a stale match line is the kind of error that makes it onto a printed set. A drifted viewport you might catch in review. A match line pointing at the wrong sheet number reads as correct right up until the contractor in the field tries to follow it.
What a match line was built to do
A match line in Plan Production is a boundary marker. The wizard places view frames along the alignment, and where two frames meet, it drops a match line to tell the reader the plan continues on the next sheet. The label points at the neighboring sheet. The line sits at the frame seam. That's the whole contract.
And like everything in Plan Production, it's a contract written for a design that's already finished. The match line is placed once, at a seam that exists once, and the assumption is that the seam will never move. But the question was never if the design changes. It's when. And when it does, the seam moves, and the match line doesn't.
Why they drift
Three things go wrong, and they go wrong in a stack.
The first is placement. Match lines live at view frame seams. When the design changes and you regenerate the frames, the seams land in new stations. But the match lines you placed don't ride along. They sit at the old stations, orphaned from the seams that justified them, pointing at geometry that has moved out from under them. You can regenerate the frames in seconds. Putting the match lines back where the frames now are is the afternoon.
The second is the label, and this is the one people get wrong when they describe it, so it's worth being precise. The native match line label can show the sheet number. There's a Next Sheet Number and a Previous Sheet Number property built for exactly that. The catch is where that number comes from. It isn't read live from the Sheet Set Manager. It's a value stored on the view frame, shown as #### until the sheets are generated, and each view frame group restarts its numbering at one. So on any project with more than one alignment you get several Sheet 1s, and you fix it by hand: set the real sheet number in the view frame properties, then rename the matching sheet in the Sheet Set Manager so the title block agrees, then trust that the three stay in step. They don't, for long. The label, the view frame, and the SSM are three copies of the same number kept in three places, and every change is a chance for them to disagree. This is why every firm I've talked to has a LISP routine, an X-data property set, or a third-party sheet tool patching the gap. We all built the same bridge because the tool left the same water.
The third is the geometry of the line itself. On a tangent, a match line is a clean perpendicular and nobody thinks about it. On a curve it gets fussier: the seam isn't square to anything obvious, the label placement and the point where the line crosses the alignment both need attention, and the automatic position often isn't the one you'd choose. Civil 3D gives you controls to reposition it, which is the tell. The placement that reads correctly on a curve is a judgment call, and on a long corridor with a lot of curvature, that judgment repeated at every seam is the part that eats the afternoon.
Stack the three and you get the thing everyone recognizes: a set of match lines that were correct on the day they were placed and have been slowly lying ever since.
The workarounds we've all built
The LISP remap is the famous one, but it's not the only one.
Somebody draws the match lines by hand after the wizard runs, because the firm has a standard the wizard doesn't honor, and hand placement is the only way to hit it. Somebody trims the viewports back to the match line by hand, because the match line tool marks the boundary but doesn't clip anything, so the plan happily bleeds past its own seam until you stop it. Somebody keeps a side note of which label points at which sheet, because they've been burned by the frame-versus-sheet mismatch before and don't trust the label on sight anymore.
Every one of these works. Every one of them assumes the design holds still. So when the alignment moves, you don't just redo the match lines, you redo the workarounds you built on top of the match lines, every cycle, and you fold it into the cost of the work and don't mention it.
The honest cost
On a 40-sheet set, the first pass of match lines is not the expensive part. Placing them, labeling them, trimming the viewports behind them, reconciling the labels against the real sheet numbers, that's a chunk of the initial build but it's a known chunk.
The expensive part is the second pass, and the third. The engineer moves the alignment 200 feet at the north end and re-cuts the corridor. The frames regenerate. Now every seam downstream of the change has shifted, every match line is at the wrong station, and the viewport behind each one needs re-trimming to the new boundary. That's not a five-minute fix. That's a careful pass down the whole set, in order, checking each seam against geometry that has stopped matching the page.
Do that across three revision cycles and the match lines alone have eaten more hours than the original placement. It's a quiet line item, but it's a real one, and it's almost entirely caused by the gap between a tool that runs once and a design that doesn't.
What changes when the match lines move with the design
The fix isn't a better wizard for placing match lines. It's match lines that aren't placed once.
That's how SheetAgent for Civil 3D treats them. A match line isn't a static line you drop at a seam and babysit. It's tied to the seam itself, so when the design moves and the tiles shift, the match lines move to the new seams instead of stranding at the old ones. The label reads the sheet number from one source, the same one the title block and the sheet manager read, so there aren't three copies to keep in step. The see sheet call is right because there's only one number, not a value stored on the view frame that drifts from where the sheet actually lands. The viewport behind the line clips to the seam as part of the same operation, so the plan stops at its boundary without a separate hand-trimming pass.
The curve case is handled where the geometry actually lives. Instead of dropping a line at the seam and hoping it reads right, the match line lands so that on a curve it crosses where it should and reads the way a reviewer expects, without the hand-nudging the native workflow leaves you to do. That was one of the harder things to get right, because curves are exactly where the hand workarounds were hiding, and it's the part that most makes the difference feel like the tool is finally doing the judgment you used to do yourself.
The first placement still happens. But the second pass, after the alignment moves, is the tool re-seaming the set against the new geometry while the labels and the trims come along for the ride. Minutes, not an afternoon. The change stops being the thing that breaks the match lines and goes back to being just a change.
Why this is the one that matters
A stale viewport is an internal embarrassment. A stale match line is the error that reaches the field. It's the one a contractor follows to the wrong sheet, the one that turns a clean set into a clarification request, the one that costs trust on a project long after the afternoon you spent fixing it is forgotten.
Taking the friction out of match lines isn't only about the hours, though the hours are real. It's about the set telling the truth at the moment it issues, instead of telling a truth that was accurate three revisions ago. A set whose match lines always agree with the geometry is a set you can issue without the quiet dread of the one label you forgot to chase. That confidence is worth more than the time.
What's next
This was the alignment half. Next time, the other trigger: when the geometry holds still and the scope moves instead. A reach gets cut, a connection gets added, the sheet count changes, and the whole set has to renumber. That renumber walks an off-by-one error through every see sheet label in the set, on every tiled drawing, not just the ones along an alignment. After that, the title blocks and the Sheet Set Manager, and then the key plans and the project-wide picture across multiple files and multiple designers, which is the part almost nobody automates well.
If you've ever chased a see sheet label down a 40-sheet set wondering which ones you missed, you already know why this is part two.
See it on your own project at setline.ai.