🔍 Seeing Structure
Field Notes on Perception: Entry #2
Early in my career, I discovered I had an unusual skill.
Drop me into a legacy codebase—spaghetti logic, years of random commits, no documentation—and I could still find my way. Not just get it running, but understand it. I didn’t need to read every file. I didn’t even try.
I’d scan a few files, look at the folder structure, find the core loop, pick up the naming conventions (or lack of them), and within a day I could tell you:
How many people had worked on the system
Which components were rushed
Which features had been bolted on after the fact
Which functions were safe to touch, and which were radioactive
To me, it felt obvious. To others, it felt like magic.
I’ve since realized that what I was doing wasn’t reading code. I was reading structure. Code isn’t just logic—it’s fossilized thought.
Let’s say you look at a C++ function that is 650 lines - that says something. You stumble across a file whose ratio of comments to logic is 10:1. - that says something. A node routine that uses both the then\catch pattern *and* the async\await pattern - that says something. A sql statement that uses QUALIFY. A typescript project running a linter that has @typescript-eslint/no-explicit-any disabled. A variable named i_hate_this.
You can feel the author’s intent, or indecision, or recklessness. You can see where two mental models clashed. You can tell when someone just learned the language, or were playing with a new technique, or when they stopped caring.
I’ve never needed perfect information to map the system. A few fragments are enough to sketch the rest because every system is shaped by pressure and pressure always leaves a trace.
🔥 All Code Is Pressure
At some point, I stopped seeing code as logic and started seeing it as pressure relief.
This has become my way of seeing the world.
I don’t trust clean data. I trust friction.
I don’t trust perfect documentation. I trust the naming patterns someone gave up on halfway through a project.
I don’t need trending insights. I want to trace what’s been quietly stable for years.
I don’t look for the loudest signal. I look for the place no one is watching—but everything moves through.
We don’t talk about it much, but everyone’s thinking leaves a trail. It shows up in:
Codebases
Schemas
Folder hierarchies
Chart design
Pipeline weirdness
Metadata inconsistencies
Even how a person writes comments—or doesn't
When you look at structure long enough, you stop asking what’s “right.” You start asking: what kind of thinking made this?
That’s where the truth lives.
In my current work, I spend a lot of time with metadata, data pipelines, lineage, and organizational systems that have collapsed under their own complexity (is this you? check out cmdrvl.com). Different inputs, same patterns.
I don’t look for the perfect dashboard. I look for:
Tension between systems of record and systems of reporting
Mismatches between naming conventions and ownership
Latent friction hiding behind happy-path workflows
Same as with code: I’m not after the surface logic. I’m after the invisible pressures that shaped it.
This way of seeing—maybe it’s called cognitive pattern recognition—feels more valuable than ever. 1
We’re living in an era where information is abundant, but trust is scarce. Everyone’s got data. Few can trace the judgment that shaped it. And if you can’t trace it—you can’t trust it.
But once you learn to see structure, even in fragments, you don’t need to control the chaos. This this is the important bit because no one can control the chaos at this point. You just need to be able to identify where the stress is accumulating.
👞 Why does any of this matter?
Because structure is how we know what we know.
And in a world where we’re being asked to make faster decisions with more uncertainty, the ability to see past noise and detect actual shape—real, durable shape—isn't just useful. It’s how you stay human.
It’s how you stop reacting to everything.
It’s how you protect your judgment.
It’s how you make space to think clearly when everything is yelling.
The game is no longer to be in the business of knowing things.
I used to think being good at this meant I was just good with code. Now I think it’s helped me build a better way of being in the world:
I trust slowness.
I trust the seams.
I pay more attention to what persists than what trends.
I build things I can explain backward.
I surround myself with people who stay close to the work—even when no one’s watching.
It’s not cleaner.
It’s not faster.
But it holds.
And for now, that’s enough.
Happy Monday!
Zac
@dealcharts
https://cmdrvl.com
Field Notes on Perception is an ongoing series about how we see—systems, data, patterns, and the invisible structures that shape how we think and build. It’s a personal lens on trust, clarity, and cognition in a noisy world.
I didn't read either of these - Ulric Neisser, Cognitive Psychology (1967) or Hawkins & Blakeslee, On Intelligence (2004) - but I think some folks who are really good with machine learning foundations are up on these.