One resolved map
Static structure and live telemetry are correlated to the same node IDs, so a trace lands on a real function, not on a string that happened to match.
One map of the code, for engineers and agents
Navigate code by meaning,
not text.
Poka Yoke gives engineers and coding agents the same resolved map of the code — and of what it does at runtime. Deterministic static graph, live telemetry overlay, and an MCP surface both can query.
Free for individual use · Source-available alpha · Runs locally on your machine
Why it exists
Text search finds strings. It does not find structure.
Coding agents spend most of their budget discovering what already exists — call chains, overrides, interface implementors — and re-discovering it after every edit. On a small script, that works. On a large, complex codebase, it quietly drifts.
Agent-free generation
Compile-based graph generation. Same code, same graph, same IDs — no tokens spent, no drift between runs. Regenerating costs nothing.
MCP tools, not dumps
Agents query the graph directly — callers, callees, path-trace, type hierarchy — instead of reading the whole codebase into a prompt.
“Static analysis is incomplete by nature. The best published Python call-graph tool reports about 99% precision and 70% recall. Poka Yoke reports what it cannot resolve instead of guessing.”
How it fits together
One graph. One telemetry stream. Two audiences.
People use it through the visualizer; agents use it through MCP. The same artifacts sit underneath both.
Source
Code, AIDL, Gradle
Static graph
Stable node IDs
Overlay
Live telemetry
Visualizer
For humans
MCP
For agents
For humans
- Filter large graphs without losing the plot
- See a live trace rendered on the same view as the structure
- Inspect call sites, parameters, imports, data definitions
- Unresolved edges drawn differently from resolved ones
For agents
symbol.search,callers.get,path.trace- Plan against stable node IDs that survive edits
- Edit the graph to state a plan before writing code
- Read only the spans the plan touches — not the whole codebase
The 60-second version
See it in 11 slides.
The product story, from "what it is" to "where it pays off". Use the arrows, the ← → keys, or swipe. Autoplay off by default.
Origin
A narrow, practical irritation.
Poka Yoke started from a specific irritation: videocoding works fine on a small script and falls apart on a large, complex codebase. Not because the model gets dumber — because nothing in the workflow tells it, or you, when the shape of what's being built has quietly drifted from what was asked for.
The gap doesn't announce itself. It shows up weeks later as a bug nobody can explain, or never shows up at all and becomes technical debt with no paper trail.
The instinct that follows from that is old, not new — it's Deming's, from a Toyota factory floor seventy years before any of this: catch the mistake by the shape of the process, not by inspecting the output afterward. Applying that to code meant asking what the equivalent of a factory's physical jig or gauge would be for software. The answer turned out to be a graph — a structural map of what the code actually looks like, that could exist before the code does, be checked against the code once it's built, and keep being checked after it ships, against what the system actually does at runtime.
A second, personal influence shaped how that graph gets used day to day, borrowed from Heinlein's Waldo — build tools to build tools, and give an agent its constraints before its instructions, not after. That ordering produced better results than the more natural instinct of stating the goal first and hoping the constraints get respected.
“Poka-yoke” is a Japanese term from lean manufacturing — a mechanism that makes a mistake impossible to pass on, rather than a check that catches it afterward.
About
Built by BreakThrough Technologies LLC.
Poka Yoke is being built by Tyrone Thomas at BreakThrough Technologies LLC. The methodology is free and will stay that way; any commercial tooling built on it sits alongside it, never in front of it.
The alpha focuses on Android / mobile-mesh architectures — where static parse, compile-time accuracy, and live telemetry correlation genuinely pay off — with broader language and platform support on the roadmap.
Free alpha
Try Poka Yoke.
The alpha ships as a local-first bundle — parsers, graph generator, viewer, and MCP server — for evaluating the discipline on a real codebase.
Download free alpha →Requires macOS or Linux · Python 3.11+ · No account required.
Support the work
Buy the developer a coffee.
Poka Yoke is built nights and weekends. If the methodology or the tooling has been useful, a coffee keeps the parsers fed.
☕ Buy me a coffeeContact
Tell us what you're building.
Design-partner conversations, bug reports from the alpha, or methodology questions — all welcome. We read everything.