Part 2 of the Blank Slate

Every framework is one idea wearing a costume of ceremony. Here's how to find the idea, and what happens when you can't.

Last post I held up the mirror, the empty slab, and told you what most people see in it: the readout comes back and they can't say why it's wrong, because what they were carrying was jargon with good posture. And that's the problem with jargon: it's vocabulary, rarely mental constructs. Nothing behind the words holding weight or meaning. It exists to make you feel smart for saying it and the room feel smart for nodding along in understanding. Acronym and jargon bingo, some keynotes, and for good measure - throw in some certifications. Let celebrities rise and it comes from the same place every time.

Every framework you've ever been certified in, evangelized, or forced to sit through a workshop about is one load-bearing idea wearing a costume of ceremony. One wall holds the building up. The rest is drywall, wallpaper, and a gift shop. The industry sells the costume, because the costume is billable. The idea is free - want to know more?

I've been inside the gift shop and worked the booth. I beta-tested the Professional Scrum Developer exam. Not took it, tested it, the actual test before it shipped. It's the only certification I got. Now, being that close to the machinery was a properly useful experience - but there was a bit of a problem. They weren't checking whether I could think and do any of the concepts, much less defend them other than "that's not scrum". That was my line. Every other certification I saw after that I gave them a load-bearing test. I also worked at VersionOne for years, which meant a front row seat to every method our customers were dying for. (Also, safE still sucks. Fight me.)

So about that load-bearing test

Here's the test that matters, and it's the same mirror from Part 1: name the load-bearing idea of the thing you're defending right now, in one sentence, without the vocabulary that came on the box or as a conference headliner. If you can't, you're not practicing the framework. You're wearing it. What does load-bearing mean? Take it away, and everything else about the framework falls apart and cannot stand on its own.

Watch me run it. Three frameworks: one deep, two fast. The deep one is SOLID principles, a great framework (no, really), because it's the one I had to tear down to its one-liner. Ok, really it's 3 but stick with me.

(Non-coders: skim the letter walk if you want. The point isn't the letters. It's the move. Pick it back up at "The speed round" and you'll have lost nothing.)

The deep walk: SOLID principles

I ran this test on SOLID because I noticed a pattern after using it as a strong guiding principle for years. What I found wasn't five principles. It was one load-bearing idea, some drywall repeating it in different rooms, and a couple of beams the box never shipped. So I stopped carrying SOLID and shaved it down to the S - but brought along a Y and a D. SYD: Single responsibility, plus YAGNI and DRY, two principles SOLID never included (they're XP and The Pragmatic Programmer) and badly needed. That wasn't knocking SOLID down. That was an audit: keep what holds weight, name what's repeated, import what's missing.

The bar-stool compression went: "do SYD and the rest of SOLID just... happens." Great line. Gets nods. Fits in a tweet. So I put it on the slab, and the mirror handed back "that's great!" Of course it did. I gave it the compliment, not the recipe. Grandma's cookies are the best, everyone agrees, and nobody can bake them, because the recipe never got written down. The glaze wasn't the mirror failing. It was the mirror accurately reflecting an empty slab. So I went back with the receipts: why the other OLID got shelved, which patterns lean on which letters, where "just happens" stops being literally true. What came back is the version below. Not my bar-stool line. The load-bearing walk it turned into once there was something on the slab to test.

S is the only load-bearing letter. Not because the other four are wrong. Because every one of them is either downstream of S or dead weight without it.

Interface Segregation falls out of S. ISP is single responsibility wearing an interface costume. If your interfaces each do one job, no client gets forced to depend on methods it doesn't use, because there are no kitchen-sink interfaces left to depend on. You don't practice ISP. You practice S and ISP shows up.

Open/Closed mostly falls out of S. Small, focused units plus DRY pushing shared behavior into composable pieces means you extend instead of edit. Composition is what S forces on you, and open-closed is what composition looks like from the outside. "Mostly" is doing some work in that sentence, and I'll own the asterisk.

Liskov and Dependency Inversion don't fall out of S. Worse: without S, they're inert. This is the part the certification slide skips. You can satisfy Liskov's letter perfectly and improve nothing, because substituting one god class for another god class is substitution theater. The contract is "everything," so honoring the contract means nothing. Same with DIP: inject a kitchen-sink interface and congratulations, you've abstracted a monster. The wiring diagram looks like the slide from the workshop and the codebase is still spaghetti. L and D aren't principles you can apply to a mess. They're principles that only mean something once S has given the words "contract" and "abstraction" something real to point at.

Here's the receipt from the shop floor: when S isn't a design consideration, you can't even test your way out - looking at you vibe coders. Writing good tests (various flavors of TDD) assumes you can get a seam around a unit, and a god class has no seams. There's a name for what happens next, and I've watched it in every shop that skipped the S: GDD. Guilt Driven Development. You should have written the tests. You didn't. Now you're writing them at the worst possible moment, under duress, or you're not writing them and hauling the guilt around instead. Call it debt, guilt, whatever, either way, you end up doing strangulation on the legacy mess just to earn the right to start doing S properly, so that testing can work, so that the rest of the letters have something to hold on to. The whole stack of practices rests on one. single. wall.

That's the upgrade to the definition I gave you up top. Load-bearing isn't just "take it away and the rest falls apart." It's this: everything built on top of it gets cheaper. Tests get cheap. Change gets cheap. The other letters go from workshop vocabulary to things that quietly happen. Knock out the S and it doesn't matter how loudly you recite the other four. The building is coming down with the certificates still on the wall.

The speed round

Same move, two frameworks you've lived through even if you've never written a line of code.

LEAN. Strip the kanban boards, the Japanese vocabulary, the value-stream-mapping offsites. The load-bearing idea: stop doing work that exists to make the org feel busy. That's it. Every artifact of LEAN is a device for making waste visible so you can stop lying to yourself about it. And notice what most shops did: they adopted the boards, kept the waste, and now the waste has swimlanes. The costume, without the wall.

XP. This one's fun because XP marketed itself as the rebellion, the return of the Jedi. Lightweight! No heavy process! No rules! Bullshit. Strip the ceremonies and XP is the most disciplined regime this industry ever produced: pair every day, write the test before the code, integrate constantly, release small. Monks have looser schedules. And the load-bearing idea under all that discipline is embarrassingly simple: talk to people. Every practice in XP is a conversation on a timer. Pairing is talking in seconds. The planning game is talking in weeks. The on-site customer is talking as a permanent fixture. Slow the loops and the shop degrades. Stop the talking and the loops go dark, and you're shipping fast into a void. "No rules" was the sales pitch (really it was fear from people who wanted control). Discipline enforced through humans instead of documents was the product.

(Agile gets no paragraph here. It gets Part 3)

The pattern you just watched

The Blank Slate now turns into the load bearing test - run the test yourself before your next standup, retro, or architecture review. Whatever you're defending: one sentence, load-bearing idea, no box vocabulary. If the sentence comes out clean, you've got the load-bearing wall. If what comes out is the ceremony described in different words, the mirror just told you which one you own: the wall, or the wallpaper.

And notice something before you go. Strip these three down to their load-bearing members and they start to rhyme. Single responsibility is legible code. Cutting waste is a legible workflow. Talking on a timer is a legible team. Disciplined, honest feedback, pointed at code, at work, at people. Almost like the industry has been selling the same key for thirty years with a different grind on it, in a different gift-shop box, at a different conference.

There was a guy at every shop who carried the whole ring. He knew which wall held each building up, and he could open every door. Most orgs fired him, relabeled the chaos, and called it a transformation.

Next post: Flattening the Ladder.

This is Part 2 of The Blank Slate, a series on what happens when your thinking finally has to stand on its own.