Leo Gorodinski

Founder @CohesiveSystems, Prev: Co-founder/CTO @AlvysTeam, First engineer → VPE @JetTechnology acq. by @Walmart

[Leo Gorodinski @eulerfx]

@rjs Implementable compositions 🙏

[Leo Gorodinski @eulerfx]

This is what should drive the design of agent-first programming languages: primitives at the level of nouns and verbs, so agents reason in the vocabulary people already use to describe the system.

[Maggie Appleton @Mappletons]

I know I've been prompting my agents correctly when they present interfaces at the grammar, noun, and verb level. Took a lot of skill crafting to get here but god it's refreshing to work at the correct abstraction level and not like "my brother in christ why is this a modal?"

[Leo Gorodinski @eulerfx]

Closed-loop tasks work because success is checkable.

Most of a long-lived system isn't like that: what must remain true lives in people's heads and in scattered code.

The goal is making that checkable, so agents can hill-climb against it too.

[Matt Pocock @mattpocockuk]

I feel like I need a word for the type of task that agents are really good at

I.e. where it has 100% of the data, it can run experiments, verify independently, and hill-climb towards its destination

On these tasks my trust level is totally maxed-out and the results are incredible

Just need a word for them

[Leo Gorodinski @eulerfx]

Agreed for wrappers that only hide implementation details.

But there’s another kind of abstraction that exposes semantics. A query DSL makes changes easier even if you never swap databases: the operation becomes a value you can inspect, transform, and enforce policies on, like tenant isolation or auditing.

More generally, I’d want abstractions that let you observe and intervene in execution, not just hide it.

[Leo Gorodinski @eulerfx]

Point 4 is the one I keep dwelling on: we can prove an implementation correct against a spec that doesn’t capture the intended behavior.

I see two paths to closing the model-to-code gap: embedding specs in code, or making the model the source of truth from which code is derived.

The latter seems promising for system-level properties like “never charge a customer twice,” which span services, persistence, and failures.

But neither eliminates the need to validate the model against intent. Curious which direction you expect things to go.

[Leo Gorodinski @eulerfx]

Yes, someone still has to read it. The difference is what they're reading: a model in the terms a domain expert already uses to describe the system, not the thousands of lines of code generated from it. And they don't only read it, they can run scenarios against it. Since the step from model to code is mechanical, the review happens once, at the level where intent lives.

[Leo Gorodinski @eulerfx]

When an LLM writes a formal spec from requirements plus possibly buggy code, it can produce a spec that the buggy code satisfies: either too weak, or shaped by the implementation. The verifier passes it. Advanced prompting didn't fully fix it.

This is verification vs. validation. Proving code meets a spec says nothing about whether the spec captures intent.

One way out: make the model the implementation. Compile it instead of hand-writing code that's supposed to match it. That closes the model-to-code gap. Validation remains, but it happens against a model a domain expert can read and explore through generated scenarios, not against thousands of lines of code.

https://t.co/Mpv37MGLiE

[Leo Gorodinski @eulerfx]

Interesting.

I’ve been asking folks how they organize their bots, and granularity keeps coming up. If bots can orchestrate their own pipelines, perhaps the main reason to expose one is when you want to interact with it directly?

Curious where the dust settles between the project-centric model and the bot-centric model.

[Michael Timothy Bennett @MiTiBennett]

👀

https://t.co/CahGakcpKb

[Leo Gorodinski @eulerfx]

@MagnusGrimeland @Lovable @AntlerGlobal Cohesive lets teams build software that does what they intended, at the speed agents write code.

[Leo Gorodinski @eulerfx]

The "agents in check" framing resonates.

I've heard this unease from tech execs: a lot of code is getting generated, and it's hard to know whether it does what was intended. Nightly jobs that reconcile docs and code help a little, but they don't settle it. You want the check earlier, while the change is being made.

[Leo Gorodinski @eulerfx]

Yes.

The state machine is there whether you make it explicit or not.

But making the machine explicit gives you things that would otherwise be out of reach: you can state invariants, reason about reachability, and check whether the implementation admits behaviors outside the intended model.

[Leo Gorodinski @eulerfx]

@__apf__ We get some yellow leaves in San Diego in October

[Leo Gorodinski @eulerfx]

Thanks for sharing.

AI clarifies the difference between why we need partners and why we want them. As it takes over more of the labor, some practical reasons weaken: division of work, pooled resources, keeping the fire going.

What becomes clearer is what was most valuable all along: someone who shares your conviction, and chooses to build alongside you. Someone who was there when it worked.

[Leo Gorodinski @eulerfx]

On it.

Functoriality, sheaves, stacks, descent, double categories, and the Grothendieck construction all come up in the modeling docs. Capabilities form a distributive lattice of predicates, giving a Zariski-like space of capability profiles. No structure sheaf, though, so no schemes yet. Also exploring cohomology for emergent effects like feedback loops.

To be clear, the math informs the design rather than being the focus.

See also @hiroyuki_n_1986

[Leo Gorodinski @eulerfx]

@MatijaSosic 🙏 🫡

[Leo Gorodinski @eulerfx]

I agree we’re all still internalizing it.

There’s an Amdahl’s law dynamic here. Engineers always spent more time understanding than writing code, and much of that understanding happened in parallel with coding. AI accelerates coding, but if comprehension doesn’t accelerate at the same rate, the overall speedup is limited.

So some of the padding may be for understanding.

Deadlines used to force teams. But now this pressure can lead teams to ship code they didn’t fully internalize.

[Leo Gorodinski @eulerfx]

Nice.

Have you considered selective evaluation like “Trust or Escalate”? Auto-pass or fail confident cases, send uncertain ones to human review, with finite-sample error control on what's accepted.

I wonder how much review that would save, and whether ~100 labeled traces would be enough to set both thresholds.

[Leo Gorodinski @eulerfx]

@plainionist Remove code that’s still referenced and you’ll often get a compiler error, or at least a runtime failure.

Remove a natural-language instruction that constrained an agent’s behavior, and you might silently delegate QA to your users 😅.

[Leo Gorodinski @eulerfx]

@hillelogram A well-known companion quote from Knuth that touches on the deductive vs empirical distinction:

“Beware of bugs in the above code. I have only proved it correct, not tried it.”