Why table‑and‑column answers are a dead end for AI understanding
Organisations today, aren’t asking large language models to understand systems.
They’re doing something far more pragmatic — and far more limited.
They point an LLM at a piece of code and ask questions like:
- “What tables are read and written?”
- “What columns are involved?”
- “Can you summarise what this program does?”
When the model returns a clean list of tables and columns, it feels like progress.
And locally — on a single script — it often is.
But this is where the industry quietly makes a dangerous leap.
Those outputs get wrapped in automation.
The workflow gets labelled “agentic”.
And suddenly, symbol extraction is being mistaken for understanding.
Let’s be clear from the start:
If all you’ve done is automate an LLM, you haven’t built an agent.
You’ve built a faster way to generate plausible answers.
The central claim
Extracting tables and columns is not understanding code.
It is identifying symbols.
That distinction matters — because symbols alone do not explain:
- how logic connects across programs
- how transformations propagate through processes
- how changes ripple beyond a single execution unit
- how outcomes are actually produced
Tables and columns are vocabulary.
They are not meaning.
Understanding code is not about recognising names.
It’s about resolving behaviour.
Why this approach feels sufficient (at first)
LLMs are very good at:
- spotting obvious inputs and outputs
- naming structures that appear in front of them
- paraphrasing local logic into something readable
For a single program, this often looks accurate — even impressive. It can even work with a few pieces of code but once you hit the token limit drift creeps in, silently.
That’s why this pattern has taken hold so quickly. But enterprise systems are not single programs. They are connected processes, spread across files, jobs, schedules, environments, and time — evolving over years, not prompts.
And that’s where the illusion breaks.
Where it fails — quietly and at scale
Once you move beyond a single unit of code, table‑and‑column extraction starts to collapse:
- Logic spans multiple code units
- Transformations are split across steps and stages
- Intermediate states matter
- Semantics live in expressions, not object names
At that point, you no longer have “understanding”.
You have fragments without connection.
And fragments cannot support:
- impact analysis
- integration planning
- regulatory traceability
- or any form of safe automation
The most dangerous part is that this failure mode is silent.
Missing connections don’t raise errors.
They simply don’t appear.
Plausibility fills the gaps — and confidence grows precisely where certainty is lowest.
The uncomfortable observation
The industry has started calling this shallow extraction “good enough”.
Not because it actually is — but because:
- it’s fast
- it demos well
- it avoids hard engineering problems
- and it produces outputs that sound authoritative
But “good enough” understanding does not scale.
And when it’s wrapped in automation and called agentic, it doesn’t just mislead — it invites action on incomplete truth.
That’s not intelligence.
That’s risk with momentum.
Why this matters for anything calling itself “agentic”
An agent, by definition, is allowed to act.
Acting requires authority.
Authority requires truth.
If a system cannot:
- prove how an output was derived
- enumerate what it depends on
- surface what it does not know
then it has no business acting autonomously — no matter how fluent the explanation sounds.
Automating an LLM does not create agency.
It just accelerates guesswork.
Conclusion
Tables and columns tell you what exists.
They do not tell you:
- why it exists
- how it was derived
- what depends on it
Understanding systems requires more than extraction.
It requires resolving structure, behaviour, and connection — deterministically.
Next - The Myth of Agentic Code Understanding – A Technical Explanation - Link
The Full Series
- Determinism, Probability, and the Cost of Getting This Wrong - Link
- Why probabilistic language models are being mistaken for agents — and why systems expose the flaw - Link
- Stop Calling It Agentic: You’ve Just Automated an LLM - Link
- The Myth of Agentic Code Understanding – A Technical Explanation - Link
- The Minimum Deterministic Substrate What Must Be True Before AI Is Allowed to Act - Link
- Determinism Is the Forgotten Path to Success: Why the hard path is often the only one that actually scales – Link
- The Broken Escalator, Deterministic Lineage, and the Problem of Grounded Truth in AI - Link
- When Probabilistic Systems (LLMs) Pretend to Be Deterministic: A Lineage Case Study – Link
