It's starting to become obvious that if you can't effectively use AI to build systems it is a skill issue. At the moment it is a mysterious, occasionally fickle, tool - but if you provide the correct feedback mechanisms and provide small tweaks and context at idiosyncrasies, it's possible to get agents to reliably build very complex systems.
It's a similar problem in the human context, but I think the reason stuff like workflow agents haven't caught on is because humans don't really like to work this say. Writing a conditional and calling a function keeps you in your flow, but having to jump between an orchestration layer and your code with implementation details breaks that. But LLMs don't have this problem. In fact, they benefit from having all the additional information that's expressed in the graph layer.
> Mycelium structures applications as directed graphs of pure data transformations. Each node (cell) has explicit input/output schemas. Cells are developed and tested in complete isolation, then composed into workflows that are validated at compile time. Routing between cells is determined by dispatch predicates defined at the workflow level — handlers compute data, the graph decides where it goes.
No still don't understand
> Mycelium uses Maestro state machines and Malli contracts to define "The Law of the Graph," providing a high-integrity environment where humans architect and AI agents implement.
I have the same problem. The "What It Is" section starts with "Mycelium is a Clojure workflow framework built on Maestro" and that's a bit generic. Maybe something to test some AI generated code and then test if the tests are tested enough using Closure, but I'm not entirely sure.
The main question that is not obvious, is what should I use it for?
I'm talking about expressing the application as a state machine and then implementing each step in the state graph as an independent subprogram. The cells accept a state, do some work, and produce a new state. Then the graph orchestrator inspects the state and dispatches to the next appropriate cell.
I've used the analogy of a circular saw before ("it's not really sawing, because you can't feel the wood...")
It's easy to just slab on a Skil saw, cut through the beam and it'll be somewhat straight. But when every manual stroke counts, there's enough time on a human time scale to correct every little mistake. It's definitely possible to become skilled at using the circular saw, but it takes effort that it feels like you don't need at first.
This is similar. LLMs are so powerful for writing code that it's easy to become complacent and forget your role as the engineer using the tool: guaranteeing correctness, security, safety and performance of the end result. When you're not invested in every if-statement, forgetting to check edge cases is really easy to do. And as much as I like Claude writing test cases for me, I also have to ensure the coverage is decent, that the implicit assumptions made about external library code is correct, etc. It takes a lot of effort to do it right. I don't know why Mycelium thinks they invented interfaces for module boundaries, but I'm pretty sure they are still as suceptible to that "0" not behaving as you'd expect, or the empty string being interpreted as "missing." Or the CSG algorithm working, except if your hole edges are incident with some boundary edges.
I agree with everything you're saying here, and I'm not arguing the approach eliminates the need for the human to be in the loop. That's not the goal.
What I'm trying to do is to create hard context boundaries which help both the human and the agent understand what the code is doing. With Mycelium, you have a graph expressing the top level logic, so you have a declarative workflow that you can review. With traditional code this is mixed in together with the implementation details, and you have to tease out the business logic by reading through the code.
Mycelium creates a hard boundary between implementation details which live in the cells, and the high level business logic of the application. You can set up a workflow manifest which declares what you're doing. Then you can go an implement each step in form of a cell. And then you can review it and test it in isolation without having to consider the entire application.
This is the part that reduces the cognitive load and makes it easier to ensure that the code is doing what's intended.
As a note, I'm not arguing that I invented anything fundamentally new here. Workflow engines have been around for a while. I'm simply applying the idea directly in the context of coding agents.
11 comments
[ 2.8 ms ] story [ 31.0 ms ] thread> Mycelium structures applications as directed graphs of pure data transformations. Each node (cell) has explicit input/output schemas. Cells are developed and tested in complete isolation, then composed into workflows that are validated at compile time. Routing between cells is determined by dispatch predicates defined at the workflow level — handlers compute data, the graph decides where it goes.
No still don't understand
> Mycelium uses Maestro state machines and Malli contracts to define "The Law of the Graph," providing a high-integrity environment where humans architect and AI agents implement.
Nope, still don't
The main question that is not obvious, is what should I use it for?
It's easy to just slab on a Skil saw, cut through the beam and it'll be somewhat straight. But when every manual stroke counts, there's enough time on a human time scale to correct every little mistake. It's definitely possible to become skilled at using the circular saw, but it takes effort that it feels like you don't need at first.
This is similar. LLMs are so powerful for writing code that it's easy to become complacent and forget your role as the engineer using the tool: guaranteeing correctness, security, safety and performance of the end result. When you're not invested in every if-statement, forgetting to check edge cases is really easy to do. And as much as I like Claude writing test cases for me, I also have to ensure the coverage is decent, that the implicit assumptions made about external library code is correct, etc. It takes a lot of effort to do it right. I don't know why Mycelium thinks they invented interfaces for module boundaries, but I'm pretty sure they are still as suceptible to that "0" not behaving as you'd expect, or the empty string being interpreted as "missing." Or the CSG algorithm working, except if your hole edges are incident with some boundary edges.
Edit: spelling
What I'm trying to do is to create hard context boundaries which help both the human and the agent understand what the code is doing. With Mycelium, you have a graph expressing the top level logic, so you have a declarative workflow that you can review. With traditional code this is mixed in together with the implementation details, and you have to tease out the business logic by reading through the code.
Mycelium creates a hard boundary between implementation details which live in the cells, and the high level business logic of the application. You can set up a workflow manifest which declares what you're doing. Then you can go an implement each step in form of a cell. And then you can review it and test it in isolation without having to consider the entire application.
This is the part that reduces the cognitive load and makes it easier to ensure that the code is doing what's intended.
As a note, I'm not arguing that I invented anything fundamentally new here. Workflow engines have been around for a while. I'm simply applying the idea directly in the context of coding agents.