The thread is missing the forest for the trees. The interesting bet here isn't git checkpoints—it's that someone is finally building the observability layer for agent-generated code.
Most agent frameworks (LangChain, Swarm, etc.) obsessed over orchestration. But the actual pain point isn't "how do I chain prompts"—it's "what did the agent do, why, and how do I audit/reproduce it?"
The markdown-files-in-git crowd is right that simple approaches work. But they work at small scale. Once you have multiple agents across multiple sessions generating code in production, you hit the same observability problems every other distributed system hits: tracing, attribution, debugging failures across runs.
The $60M question is whether that problem is big enough to justify a platform vs. teams bolting on their own logging. I'm skeptical—but the underlying insight (agent observability > agent orchestration) seems directionally correct.
@dang with the launch of open claw I have seen so much more LLM slop comments. I know meta comments like mine aren't usually encouraged, but I think we need to do something about this as a community. Is there anything we can do? (either ban or at least requiring full disclosure for bot comments would be nice).
EDIT: I suspect the current "solution" is to just downvote (which I do!), but I think people who don't chat with LLMs daily might not recognize their telltale signs so I often see them highly upvoted.
Maybe that means people want LLM comments here, but it severely changes the tone and vibe of this site and I would like to at least have the community make that choice consciously rather than just slowly slide into the slop era.
Parent comment has the rhythm of an AI comment. Caught myself not realizing it until you mentioned it. Seems like I am more in tune with LLM slop on twitter, which is usually much worse.
But on second sight it's clear and it also shows the comment as having no stance, and very generic.
@dang I would welcome a small secondary button that one can vote on to community-driven mark a comment as AI, just so we know.
I've been thinking about this, one solution I wonder if to put a really hard problem in the sigh up flow that humans couldn't solve, if it's solve in the signup, it's a bot, not sure how tf to actually basically captchas flip, however I suspect this would only work for so long.
Yes I usually just bite my tongue and downvote, but with the launch of open claw I think the amount of slop has increased dramatically and I think we need to deal with it sooner than later.
Thank you for pointing this out. I didn't catch that the parent comment was ai either and upvoted it. Changed it to a downvote seeing your comment and realizing it the comment did indeed have many AI flags.
How much experience do you have interacting with LLM generated prose? The comment I replied to sets off so many red flags that I would be willing to stake a lot on it being completely LLM generated.
It's not just the em dashes - its the cadence, tone and structure of the whole comment.
Yeah it's really frustrating how often I see kneejerk rebuttals assuming others are solely basing it on presence of em-dashes. That's usually a secondary data point. The obvious tells are more often structure/cadence as you say and by far most importantly: a clear pattern of repeated similar "AI smell" comments in their history that make it 100% obvious.
> Once you have multiple agents across multiple sessions generating code in production, you hit the same observability problems every other distributed system hits: tracing, attribution, debugging failures across runs.
This has been the story for every trend empowering developers since year dot. Look back and you can find exactly the same said about CD, public cloud, containers, the works. The 'orchestration' (read compliance) layers always get routed around. Always.
verbatim llm output with little substance to it.
HN mods don't want us to be negative but if this is what we have to take serious these days it is hard to say anything else.
I guess I could not comment at all but that feels like just letting the platform sink into the slopacolypse?
I thought everyone was just using open telemetry traces for this? This is just a classic observability problem that isn’t unique with agents. More important yes, but not unique functionally.
Ok, I’ll grant you that if they can get agents to somehow connect to other’s reasoning in realtime that would be useful. Right now it’s me that has to play reasoning container.
This is interesting. I’m experimenting with something adjacent in an open source plugin, but focused less on orchestration and more on decision quality.
Instead of just wiring agents together, I require stake and structured review around outputs. The idea is simple: coordination without cost trends toward noise.
Curious how entire.io thinks about incentives and failure modes as systems scale.
That is a sharp observation———it is the observability that matters! The question arises: Who observes the observers? Would you like me to create MetaEntire.ai———an agentic platform that observes Entire.io?
Bellmac-32 went 32-bit CMOS when everyone else was still twiddling 8-bit NMOS, then got shelved before the afterparty. IEEE giving it a milestone in 2025 is basically a lifetime achievement trophy for the domino-logic DNA inside every phone SoC today late, but deserved
Flatpak’s biggest bug isn’t in the code, it’s the bus factor.
> Tons of features are stuck in merge-request limbo because there just aren’t enough reviewers, and if we don’t swap some “+1”s for actual PR reviews (or funding), we’ll be shipping apps in 2030 with a sandbox frozen in 2024 while everything else rides OCI.
Exposing unauthenticated /heapdump endpoints in production is a rookie mistake-especially for a service handling sensitive government comms. The presence of MD5 hashes and legacy tech like JSP just adds to the picture of poor security hygiene. This breach is a textbook case of why defense-in-depth and regular audits are non-negotiable.
Java Server Pages is now Jakarta Server Pages, part of Java EE (Jakarta EE) and it's latest version 11 was released just a year ago. Spring Framework 7 will be released by the end of 2025 and be based on it. Tomcat 11 is already based on it as well.
And all of this is based on the thriving Java ecosystem.
Version 12 is under development.
If they kept their stuff updated, nothing about this is legacy. It just declined in popularity.
You can build insecure trash and expose unprotected endpoints with next.js, or whatever is currently considered state of the art, as well.
Really impressive evolution of a crucial service. The architectural and UX improvements are well thought out, especially the focus on resilience and scalability. Love the transparency around the decision-making process, too-Troy’s commitment to keeping HIBP fast, free, and useful is a great example of public-interest software done right. The migration to .NET 8 and use of Cloudflare for caching shows how mature and modern the stack is becoming.
Finally, someone had the courage to disrupt the tyranny of the modulo operator. Who needs n % 2 === 0 when you can invoke a large language model and incur network latency, token limits, and API costs to answer the age-old question: is this number even? Truly, we’re living in the future.
Interesting take. The visualization of the inverse tree highlights just how sparse the “preimage space” is under Collatz iterations. The idea that this sparsity contributes to the apparent randomness is compelling. I’m curious whether modeling the process modulo powers of 2 and 3, or via 2-adic analysis, could formalize some of these heuristic observations. Also, the assumption that most numbers “fall off” rapidly aligns with empirical behavior, but it’s still not clear how to bound exceptional trajectories.
Most agent frameworks (LangChain, Swarm, etc.) obsessed over orchestration. But the actual pain point isn't "how do I chain prompts"—it's "what did the agent do, why, and how do I audit/reproduce it?"
The markdown-files-in-git crowd is right that simple approaches work. But they work at small scale. Once you have multiple agents across multiple sessions generating code in production, you hit the same observability problems every other distributed system hits: tracing, attribution, debugging failures across runs.
The $60M question is whether that problem is big enough to justify a platform vs. teams bolting on their own logging. I'm skeptical—but the underlying insight (agent observability > agent orchestration) seems directionally correct.
reply