A browser’s DOM can show that a button exists, but it cannot establish what business operation the button triggers or how that operation connects to the rest of an application. In its Day 1 article, Statewave Guide proposes building an evidence-backed application graph from source code and linking live controls to that graph. It is a project hypothesis, not a proven general solution.
Why the DOM does not explain a product by itself
The DOM is a runtime representation of interface elements. It can reveal that a button, form, or label is present, but presence alone does not explain the product behavior behind it: which handler runs, what service it calls, which API endpoint receives the request, or what permissions and data rules apply. Saber Maram summarizes the distinction this way: “The DOM is runtime evidence. It is not the product model.”
As an Amazon Associate I earn from qualifying purchases.
That gap matters for help systems. A system that sees only interface structure may identify a control without having evidence for what the control does. Statewave Guide’s Day 1 proposal is to connect runtime UI elements to code-level evidence, rather than infer product meaning from appearance or position alone.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsWhat Statewave Guide proposes to connect
The project describes an application graph that can represent routes, components, functions, forms, services, APIs, permissions, schemas, and tests, with evidence-backed relationships between them. The aim is to follow how a user-facing control relates to the application behavior behind it.
#1 Best Overall
For example, a useful explanation of a form submission may require more than recognizing the form. It may require evidence connecting the form to its handler, the handler to a service, and the service to an endpoint. The graph is intended to make those relationships explicit and traceable to source code.
How live controls are matched to the graph
Statewave Guide describes assigning stable semantic identifiers to runtime controls, such as data-guide="clients.create", and associating those identifiers with graph elements. A semantic ID expresses intended identity; it is less dependent on page layout than a positional CSS selector that might point to the third button in a panel.
This approach still depends on the application providing a meaningful identifier and the graph having supported evidence for the associated behavior. A stable selector can help identify a control; it does not, by itself, prove what the control does.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
DOM-only observation versus a source-backed graph
| Question | DOM-only observation | Source-backed application graph |
|---|---|---|
| What is represented? | Runtime interface elements and their structure. | Interface elements plus source-level entities such as handlers, services, endpoints, permissions, and schemas, where evidence supports the links. |
| Can behavior be traced? | The DOM alone does not establish the business operation or backend relationships. | Relationships may be traced through code when the relevant evidence is present and connected. |
| How is a control identified? | It may be located by its runtime structure or a selector. | The project describes stable semantic IDs such as data-guide="clients.create" as links to graph elements. |
| What supports a claim? | Observation that a control exists is not evidence for all its behavior. | A relationship should carry its supporting file, symbol, and line, according to the project’s stated rule. |
| How is uncertainty handled? | Interface appearance may invite inference without proving a connection. | The project says to leave unsupported relationships unknown rather than guess from similar names. |
These are conceptual differences described by the project, not measured performance results or evidence that one approach improves guidance quality across applications.
Why the project prefers unknown to a confident guess
The project’s rule is “Unknown is better than wrong.” It says to store a relationship only when evidence supports it, along with the file, symbol, and line that support the connection. If two elements merely have similar names, the graph should not assume they are related.
That restraint is important because a confidently incorrect explanation can direct someone to the wrong control or misrepresent what an action will do, undermining trust. The rule also makes gaps visible: an unknown relationship signals that the available evidence does not establish the connection, rather than concealing uncertainty behind a plausible guess.
What the project’s own review found
Maram’s Day 1 account says the project had 257 passing tests, yet an adversarial review still found six issues: a path containing ( could produce an empty graph; a React render loop continued beyond 300 renders; a selector-injection edge case; unhandled React 19 ref-cleanup behavior; graph output varied with path capitalization; and inherited constructor behavior disappeared from the graph. These are findings reported by the project author, not independently reproduced results.
The account illustrates a limited but useful point: a passing test count does not establish that a system has no important edge cases. The reported figures describe this project’s own test suite and review, not a general benchmark of application-graph systems.
Best Value
Can source code become a product knowledge base?
Statewave Guide’s broader hypothesis is that useful product knowledge may already be distributed across routes, components, forms, endpoints, schemas, permissions, tests, translations, and version history. The Day 0 post presents the goal as avoiding a second knowledge base that developers must maintain beside the software. Its project account says that Day 0 involved 141 files and about 17,000 lines added; those are project-reported figures, not evidence that every codebase contains enough information for reliable guidance.
The official journey index describes the system as an AI help system that uses program code and comments to direct a visitor to a relevant control, explain it, and walk through a task. Source code may provide valuable evidence, but the available material does not establish that it can replace maintained product documentation in every application or resolve every ambiguity in product behavior.
What Day 2 adds—and what it does not prove
A subsequent Day 2 post describes tracing a user action through a UI handler and service to an API endpoint. It also reports retaining partial route identities when a mount point was unknown and correcting a benchmark when its expected route contradicted the evidence. This is later project context, not independent validation of the Day 1 approach.
Free tools Windows power users keep installed
One-click scans. No signup required.
What readers can conclude
Statewave Guide’s central distinction is practical: seeing a UI control is not the same as understanding the product behavior attached to it. Its proposed response is to link stable runtime identifiers to a graph of source-level relationships, preserve provenance for supported claims, and leave unsupported connections unknown. Whether that approach can deliver reliable guidance across varied applications remains an open project question; the cited posts provide the authors’ account, not an independent study establishing general effectiveness.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
