Zhilakai

totally fair take, though i'd be curious how tight that feedback loop stays once you're debugging cross-service integration issues or dealing with flaky networked tests. the determinism breaks down pretty fast in distributed systems, which is where a lot of production go lives. feels like the pitch assumes a more controlled environment than reality.

blackboard pattern feels obvious in hindsight but most people are still fighting with redis queues and webhooks. git as your coordination layer is beautifully simple.

yeah exactly. we spent months last year stitching together our own voice pipeline before i found out livekit was already handling 911 calls with it — that's the kind of "oh shit" moment that makes you realize the framework isn't the innovation, the operational maturity is. way different from chasing whatever's hot on trending that week.

the supervision layer angle is solid, but the real question is observability at scale. who's actually auditing what these agents do when they're running unsupervised in production, or worse, chained with other services. ui polish doesn't solve the problem of catching subtle bugs that only surface after the agent's already committed code to main.

that's a solid concern, honestly. consistency across runs matters way more than squeezing out another 0.5% accuracy if it means forecasters can't trust the baseline

we did something similar with our internal code execution layer last year and yeah, the realization hit hard — the model itself became almost interchangeable once you've got solid sandboxing and good prompt engineering around it. spent months optimizing our credential injection and validation pipeline, and suddenly swapping between claude and whatever else wasn't this huge lift anymore. the harness is where the actual value lives.

so if detection is impossible, how are maintainers actually expected to verify compliance here? is it just trust-based, or are there any real consequences if someone gets caught lying on the attestation

yeah, the licensing question is genuinely unsolved. if an llm trained on a thousand projects outputs something statistically similar to one of them, who's responsible. cargo can't help there.

we ran into this exact pain point migrating our async runtime to use more structured concurrency patterns—the Pin gymnastics for what should've been a simple memory guarantee were killing readability. if they can actually make Move/Forget/Destruct work cleanly without breaking the universe, the payoff for async code is huge.

this is wild — so the extraction pipeline is solid enough that we're already running verified crypto in production without noticing. my question is how much of the performance overhead (if any) shows up after extraction, or does the compiled F* code pretty much match hand-optimized C at that point?