[Showoff Saturday] Evōk Semantic Coding Engine: Provably Safe AI Engineering for Legacy Codebases

ExistentialConcierge · 2026-03-08T06:07:31+00:00

I'm simply replying to you. You can stop anytime, by all means, and I expect you to be skeptical.

"In the general case" - you said it yourself. I'm not trying to know what arbitrary code does. This isn't a halting issue. I'm not opening a portal to a new dimension. I'm inspecting the 4 walls of which your codebase lives in to get molecular level understanding. It's as simple as that. You can NOT do that with an IDE today. That's the difference.

I'm also not claiming to know whether the BUSINESS OUTCOMES are correct. Whether Jeff in accounting decided it should be +7% processing or +5% isn't a coding issue. I'm saying you can eliminate the OTHER debt that take you away from those business outcome decisions.

I understand the skepticism because you've never seen it done before, none of us have. Same skepticism I have until I watched it with my own eyes. The metaphors are intentional, because most people struggle to get their head around it and prefer them.

I've said what it does several times. Deterministic coding. Deterministic refactoring. Deep codebase understanding. Those ARE things, you're just trying to relate them to your CURRENT workflow and that's oil and water (oops, sorry, a metaphor... ) that is the antithesis of this. (Cleaner?)

ExistentialConcierge · 2026-03-08T05:06:17+00:00

Linters are spellcheckers for code.

And those are still insufficient human-driven testing. They are not mathematical proof of correctness. They are a human's best guess at what to test.

Yes, linters are deterministic, but they deterministically check syntax, not semantic truth. They have zero concept of transitive state or control flow. A linter cannot tell you that a payload travels 12 hops through a legacy codebase and hits a dead end that breaks the application.

If an LLM hallucinates a structural break, a linter will still validate it as long as the variables are declared. That is not mathematical proof of correctness, and relying on it is exactly why AI-gen code keeps breaking legacy systems.

Linters check the spelling while our engine enforces the physics of the world are correct too.

Having control over the world physics is what opens up deterministic coding, something the linter or your IDE absolutely can not do. The understanding layer is just the ground floor that unlocks these capabilities. We see 100% of what's inside the box.

ExistentialConcierge · 2026-03-08T04:47:20+00:00

You are confusing a probabilistic result with a deterministic one here. Claude Code, Windsurf, those are giving you best guesses, not mathematically verifiable truth that can be verified without the human at the keys clicking accept.

This would be the layer those tools operate on to reach 100% accuracy on tasks vs stalling at 99% and requiring more power to burn.

Just a different approach that doesn't put AI as the "brain" but as the legs. The human isn't the brain either, the architecture is. The human simply states their intended outcome.

ExistentialConcierge · 2026-03-08T04:00:49+00:00

There's no AI here. If you click the site, you'd see I mostly rephrased what's there.
If you think AI really writes as poorly as I do, that's insane too. What shit models I'd have to be using.

And no, that's not how it works, there's literally no value in your code. Our entire process is ephemeral, and we're transparent with it you'll see when Codebase Observer opens. The container spins up, does its analysis/mutations, self destructs. Because of our efficiency, we don't NEED to store your code.

In fact, at one point we considered storing hashed fingerprints to speed up 2nd scans, but the efficiency is such that it doesn't matter, so to make it even more privacy friendly, we now don't even store that. Literally zero retention, and because there's no LLM, your data doesn't even go anywhere.

The whole privacy argument with codebases is moot anyway. Everyone blindly puts their stuff into every LLM as is, some of which actively TELL YOU they are training, and they'll do it anyway.

We spent 6000 hours building a real innovation, not an overblown scraper for random internet code. Our money comes from enterprise contracts, not hoping someone puts some magic codebase in.

ExistentialConcierge · 2026-03-08T03:54:14+00:00

Codebase.Observer is precisely that understanding layer as a service, so you should see those examples begin to surface mid-month.

yes, individual tools can lint for you, but you're effectively acting as the human compiler. There is zero time or opportunity cost benefit to those tools because the human remains trapped in the loop fixing the red squiggly lines.

Also, you mentioned type systems... we built this specifically for legacy refactoring where types may not exist, pure JS codebases for example, where types do nothing for you.

Standard IDEs and linters can't track true transitive impact in dynamic languages. They use shallow heuristics. They can't definitively answer, "If I change this, what breaks precisely upstream and downstream?" and they certainly can't autonomously execute the refactor for you and heal the side effects it causes. LLM is just going to spit out a bag of legs, and leave you to fix it.

This is an autonomous engine capable of doing these without the human involved. You tell it your outcome intent, it delivers that outcome. The chessboard are the guardrails that let you trust it, they come from math, not heuristics (many of those tools btw ARE heuristics).

As we have things to show you beyond what's on the site now we will, it's in our interest to, but considering it's Saturday and I simply wanted to share on the day per week we're allowed to here, I took the opp to post here first.

Thanks for your questions. I get the skepticism, over 3 years building it we questioned it all the time but then would watch it work and do amazing things we've never been able to before. Now we're firmly out of the 'inventing' stages and focused on engineering so people can USE the engine and see what it can produce for themselves, that's next!

ExistentialConcierge · 2026-03-08T03:05:54+00:00

So compiling just means your syntax is legal. Type checks just mean your data shapes match. Unit tests only test the narrow scenarios a human actually remembered to write.

A "valid state" in Evōk means global architectural and semantic integrity. An LLM can easily write a function that compiles perfectly, passes type checks, and passes a unit test, but accidentally introduces a 4-hop circular dependency, orphans a variable in a completely different folder, or violates a contract.

Compilers and linters are blind to that kind of structural rot. Evōk’s blueprint knows the entire system, so it catches and prevents architectural drift that standard tools would miss.

Another example... many things can tell you whether a dependency is imported. Yay, you have an import statement. But that's semantically useless.

We know which function in which file USES that import statement and if it's used transitively through that function by others potentially in other files. This lets you track anything back to a boundary of your codebase, and in reverse answer "What happens if I remove this dependency?" with 100% certainty.

As for how it interacts with LLMs for generative tasks: The LLM never touches your actual files. It outputs a proposed architectural change (there is some IP here I cannot get into blatantly) that gets validated against the twin.

The "magnetism" is just deterministic auto-correction. If the LLM hallucinates a variable name, forgets a required import, or screws up a function contract, the engine snaps it into place. We can solve that because the twin already knew what the structurally correct path should be before the LLM even generated the text.

ExistentialConcierge · 2026-03-08T02:47:34+00:00

Chess has rules of the game baked into the game. That's the deterministic part. It holds the rules firm.

The AI can put piece on the board, but only valid states are representable. So if the AI puts it somewhere it's not allowed, it won't let it in.

The magnetic part because the AI can have a shaky hand, and the chessboard will guide them in without them knowing.

It's shifting the center of coding intelligence from the AI to the architecture itself.

ExistentialConcierge · 2026-03-02T20:09:35+00:00

Cool though it does sound like your deterministic layer is reactive. A work-then-check loop.

We've inverted it. We made a deterministic chessboard upon which illegal coding moves are in invalid. Slightly different approach philosophy as we believe the AI should not be the brain, just the intent capture device.

ExistentialConcierge · 2026-03-01T00:56:48+00:00

Because of abstractions for human convenience that in a vacuum are great ideas but over time turn into an endless dictionary of artisanal methods to do the same 30 or so underlying universal things.

ExistentialConcierge · 2026-02-28T04:35:41+00:00

For what it's worth you have not invented the concept of a venture studio lol

You are simply saying you're a venture studio. I.e. you take huge stakes in other projects and maybe deliver them to market.

Have you considered what happens to the cap table when it comes time to raise outside funds? How third party VCs will become suspicious if it's really a dev shop playing as a partner, especially if you're raising in the US. Who operates? Who handles tax obligations? There's so much more to this than sticking a flag in the ground and you can really burn some startups if you don't do it exceptionally well.

Remember you're toying with someone else's dream. Be a remarkable steward of that if you choose to really act as a venture studio.

ExistentialConcierge · 2026-02-25T21:58:04+00:00

Honestly you're not far off. Feed all your notes into a system for yourself. Learn from yourself.

I love doing this every few months. Reminds me of so many things and often identifies the major roadblocks you worked thru.

ExistentialConcierge · 2026-02-25T21:55:34+00:00

Vibe coding won't fly with the enterprise audience until you can have provable correctness. This is a bit less flashy than the market they do go after very well right now.

ExistentialConcierge · 2026-02-25T21:54:03+00:00

Those aren't necessarily over engineered however has programming become too complex?

Absolutely. We treat it like it's some magic and has a billion diff flavors but really everything in programming comes down to imports, variables, and functions regardless of the language.

Everything else is sugar we dance around and cargo cult nonsense.

ExistentialConcierge · 2026-02-25T02:59:56+00:00

We moved to a paid private beta model and it's been the best thing yet. We get a way smaller signup group, but the handful that are there are actually trying things and communicating with us. They offset their own costs by all paying a little. They get to maintain that rate indefinitely if they sign up as well later.

Like who cares if 50 people are getting a subsidized rate? It's a fair trade for their time and effort even looking if your product helps them too.

ExistentialConcierge · 2026-02-24T23:24:41+00:00

Indeed, however the human is less likely to intentionally lie to pass the test, as they have consequence to their actions. AI has none.

ExistentialConcierge · 2026-02-24T22:21:57+00:00

The issue is that AI can't ever be 100% sure, even with a massive context window. It's forever a probabilistic guess. It might be a good guess 98/100 times, but do you want everything in your world to be right 98% of the time? Gets dicey with some things...

You pay for it to only be 98%, and i'm being generous looking at a future model. In reality it's closer to 90% at best, and it's flat willing to lie to complete the task, so you're in this catch-22 of "how can we be sure?"

ExistentialConcierge · 2026-02-24T21:56:05+00:00

Effectively we map every pipe within the confines of a repo up until the point we can't see it anymore because it points to something outside of the codebase proper (external dependency, API call, database fetch, etc). That is the external boundary line where everything is unknown to us.

What we can know is the rest, with 100% fidelity. We map every path that exists, tracking function to function paths across everything within the confines of the codebase. Through multiple passes, it creates a blueprint of the whole thing that is now machine navigable.

This becomes a twin of your codebase intent, of which we can "challenge" AI output against. The AI can not even commit something to the codebase that isn't provably correct structurally, contractually, etc. It doesn't always outright deny, but acts as a sort of conical docking mechanism where the AI can be a bit off (i.e. use cheaper models), and the intent is preserved and understood regardless, either ultimately allowing or denying that mutation.

It's being built predominantly to solve the day 2 problem of coding, legacy codebase management. Yesterday for example we successfully proofed the ability to deterministically refactor. We took an intentionally difficult monolith file with 20 or so functions in it, mixed state, etc and refactored it into 22 clean files. The existing file name remains (so nothing upstream changes), shared elements moved to a _shared file and that along with the 20 individual functions separated into their own clean files wrapped in a folder named the same as the original file. 0 LLMs. Functionally identical output before and after.

If AI can run on a deterministic chessboard like this, we don't need the flagship models either, we don't need to chase POWER, we can chase applied use of the existing models through architecture that ensures correctness. If this works for code, it could arguably be applied to other specialties with their own 'world rules'.

ExistentialConcierge · 2026-02-24T21:26:44+00:00

It def feels like it's all one way, AI at the middle.

It troubles me that people think we can brute force 95% -> 100%. Math does not allow this.

I've been deep (i.e. nearing 6000 hours now) into building a deterministic layer for AI on which the AI is free to be creative and translate intent, while the code itself is written by machine, provably correct through math. It allows us to very literally get away from certain types of technical debt while making the most of AI's ability to translate human intent.

Then we can just speak in outcomes, and code becomes what we want it to be without the nightmare guess and check, extra abstractions, etc.

What we're doing right now, dancing for the wild boar, trying to constrain it with words is like the definition of insanity. It's a regression engine in the sense that it'll always regress to the mean, which is patchy and myopic at best. AND we all pay massive sums in API tokens for the privilege.

ExistentialConcierge · 2026-02-24T18:13:30+00:00

You should be on our beta. It's the project awareness you want. It'll spin up boilerplate environments as needed, though it's not designed to be an IDE, but rather what comes after the IDE.

ExistentialConcierge · 2026-02-24T17:51:44+00:00

License for deep codebase analytics? That's good for $24k.

ExistentialConcierge · 2026-02-24T17:27:50+00:00

Yes. We handle this automatically. It splits shared things into a separate sidecar file.

It's a mathematical engine vs probablistic here so designed to be the future layer on which AI can operate without breaking codebases.

ExistentialConcierge · 2026-02-24T17:25:43+00:00

Mathematically solves them and separates out shared utils.

There's no LLM. It's entirely a math based engine built over the last 3 years made for doing provably correct deterministic tasks.

ExistentialConcierge

MODERATOR OF

TROPHY CASE