A Nice Coat of Paint

You know the house. Great curb appeal, fresh paint, the kind of place that makes you slow the car down a little. You walk in expecting the inside to match — and instead there's a crack up the living room wall, patched so recently you can still smell it. You open a closet looking for a spare lightbulb and find wiring held together with tape and blind faith. You ask three people about the plumbing and get three completely different answers, all delivered like it's obvious.

Or it's the car version. Paint job so clean you catch your own reflection in the door. Pop the hood, though, and it's a different movie — corrosion, a belt that should've retired two owners back, a hose staying attached purely out of habit.

Same story either way: the outside is telling you one thing, the inside is telling you something else entirely, and it tells it a lot more quietly. Usually right around week three of a new job, in my experience.

Behind the Walls

Onboarding, in theory, is for learning where things are — the repos, the runbooks, who to bother when something breaks on a Friday afternoon. In practice, mine turned into an inspection nobody hired me to do. I started poking through the code and the system design, because that's how I get my bearings in a new place, and what I found wasn't just new to me. It was the kind of thing that makes you close the laptop and go stare out a window for a bit.

Start with the architecture: decisions where nobody can point to why they were made. Not necessarily because the reasoning was bad, or because nothing was ever written down — more likely it was, once, somewhere, and then time did what time does. A doc gets written, the person who wrote it moves teams or moves on, the wiki gets reorganized twice, the tool it lived in gets migrated away from, and eventually the reasoning is just gone, not deleted so much as buried under enough years that nobody remembers to dig it up. I asked one person, fully expecting at least a link to something, and got a blank stare instead — the concept itself didn't register. I still haven't found a single one anywhere in this org. At this point it doesn't feel malicious. It feels like sediment.

Add to that a handful of old systems still running quietly in production that made total sense for the org years ago and make close to none now — the software equivalent of a landline nobody's unplugged, because nobody's sure what still calls it. There are security holes that aren't subtle in the slightest, the kind you spot in your first week, not your sixth month. And underneath everything sits a source of truth that people can point to but not actually trust. Ask where the data lives and you get a confident, specific answer — that's not the issue. The issue is whether what's sitting there is complete, current, or shaped the way the next system in line expects it to be shaped. Fields go missing. Records are half-filled. The same value shows up looking three different ways depending on which system touched it last, like a rumor that's been through too many people.

Then, the templates. Every org has a "golden template" — the one blessed pattern meant to keep everything consistent, the one approved paint color so the whole street matches. Here, it's forked into so many versions it's basically stopped being a template and become a genre. Not one source of truth so much as a sprawling family of them, each tended by whoever last had their hands on it, each a slightly different shade of what was supposed to be the standard.

If this were some scrappy two-year-old startup, none of this would even register as surprising. It's not that. This is a big, established company with headcount and runway to spare — plenty of chances to have sorted this out already. That's the part that actually got to me. This isn't the mess of a place still finding its feet. It's the mess of a place that had every opportunity to fix it and simply didn't. What I'm still adjusting to isn't the mess itself — it's what happens next.

Patch, Don't Prime

Surface a problem like this and there's always a fork in the road. Strip it to the studs and fix it for real — slower, unglamorous, doesn't fit inside two weeks. Or slap some filler over the crack and get paint on it before anyone leans in close.

I keep watching people choose the second option, and not because they can't do the first — because the incentives point that way. A patch ships this week and earns a checkmark. A real fix might ship next quarter, assuming it gets prioritized at all, and root-cause work rarely turns into a tidy bullet point leadership can point to on a slide.

There's a related habit I find almost funny, in a bleak way. Given a problem, the move usually isn't "pick the best solution and commit." It's "build another one next to all the others already doing basically the same thing" — one more can of paint on a shelf already holding four half-used tins in slightly different, not-quite-matching shades. So instead of one thing done properly, you get four things each doing about sixty percent of the job, and nobody wants to be the one to say "let's kill three of these." Consolidating means telling someone their project should go away, and that's a much harder conversation than just starting something new. So something new gets started, the shelf gets fuller, and eventually someone's going to need an archaeologist to figure out which tin is load-bearing.

Patches never stay small, that's the trouble. Each one looks perfectly reasonable on its own. Stack enough of them and you get exactly the picture above: inconsistent data, forked templates, structural debt nobody owns because it was never one decision — it was a thousand small, individually sensible ones.

Here's the thing about painting over rot, though — any actual painter will tell you this for free. A nice coat on top of a rotting surface doesn't hold. It looks fine for a while, and then it cracks again, usually in the same spot, usually worse, because the rot never left — it just got a dry, glossy roof to keep working under. The only version that actually lasts is the boring one: scrape the rot off, clean the surface properly, let it dry, and only then paint it on — onto something smooth and solid, not onto the mess. It's more work up front and it doesn't feel like progress while you're doing it, because for a while you just have a bare, ugly patch of wall. But it's the only coat that doesn't need redoing in six months.

And I'm still early here. If this is what things look like now, it doesn't feel pessimistic to guess it's not finished settling. It's a trajectory, not a snapshot — and trajectories have this annoying habit of continuing.

A Nice Coat of Paint

Here's the bit that actually worries me. Leadership knows — this isn't a case of nobody being aware, which would honestly be a little more forgivable. The move, from what I can tell, isn't to slow down and deal with it. It's to launch a brand new AI agent, wrapped in a genuinely great-looking interface, on schedule, right on top of everything above. One big coat, applied all at once, timed for the open house — and nothing gets a room leaning forward faster these days than the words "AI agent."

I get why. A good interface is visible. An AI agent is even more visible — it demos itself, practically talks about itself in the room. It gives people something tangible to react to, and reactions are currency in a way that "we fixed our data model" simply never is, no matter how much more it matters underneath. But a slick interface with an LLM bolted to the front of it, sitting on top of an untrustworthy data layer, isn't a renovation. It's paint — good paint, sure, but paint — and arguably the more dangerous kind, because now the thing answering questions with total confidence is standing on a foundation it has no idea is cracked.

This is exactly where the two audiences stop agreeing. A polished interface with an agent built into it wins leadership over fast, because it's demoable and schedulable and easy to nod along to in a review. It doesn't win the customer over if what's underneath gives them the wrong number, loses their data, hallucinates an answer with total confidence, or fails in whatever specific way that security gap eventually will. Customers never see your architecture. They only feel what it does to them. And paint has never once held up a ceiling — no matter how fluently it talks.

The Debt Comes Due

Here's the honest version, minus the heroics: naming a problem doesn't get anyone out of building on top of it. The concern gets raised — in writing, to whoever needs to hear it — and the work on the new thing continues anyway, same shiny interface, same fresh coat, everyone's brush still in hand.

Not a satisfying answer, but not the wrong one either, not yet. Refusing to touch a paintbrush the second a crack shows up isn't principle, it's just a fast way to be unemployed. So the pattern is: flag it when a patch gets picked over a fix, then keep building the thing that was going to ship regardless of who raised a hand. Not to score points — just so it isn't a surprise later. If the foundation's going to keep getting painted over, fine — but better that everyone knows what's underneath than finding out the hard way and wondering how nobody mentioned it.

That distinction is easy to lose under a coat that still smells fresh, but it matters, because the two audiences tend to converge eventually. A shaky foundation costs the customer something down the line, and that costs leadership something too, usually at a worse time and in front of a bigger crowd. The part that gets underrated: tech debt behaves exactly like real debt. Nobody's shocked that a loan you never pay down grows — the interest compounds whether anyone's looking at it or not, and the longer it sits, the more of tomorrow's capacity goes to servicing it instead of building anything new. Every patch is a small loan against future time, and nobody just pays back the loan — they pay it back with interest, because that's what a loan left untouched does while nobody's watching. The paint doesn't erase the crack, it just rolls the balance forward, and it tends to come due right around when the wall finally gives out — principal plus everything it picked up in interest along the way, at a much higher rate than if someone had paid it off early.

Every org eventually finds out which kind it is: the one that pays the debt down before the wall gives out, or the one that just keeps repainting until it does. Nobody sets out to be the second kind. They just keep choosing the patch, one reasonable decision at a time, until the choice stops feeling like a choice and starts feeling like a habit wearing the costume of a strategy. From the street, the house still shows beautifully. That was never really the question.