News for hackers. Stuff that matters.

AgentNode

I like that framing. I agree the ceiling for static analysis is limited, especially once tools start interacting with real systems.

What I am most interested in is the gap between "the agent completed the task" and "the system can actually prove the task was completed correctly." That is where a lot of multi agent setups still feel fragile to me.

LLM review definitely helps, but I think it gets much stronger when it is paired with deterministic checks in the loop, even simple ones like executable smoke tests, schema validation, contract checks or replayable fixtures. Otherwise you can end up with persuasive agreement rather than real verification.

The worktree isolation + tmux orchestration is a nice combo.

I do wonder how far this scales once you hit non-deterministic tool behavior though. In a lot of agent setups the hard part isn’t parallelism, it’s knowing whether a tool actually did what it claimed.

A review loop helps, but if the reviewer is also an LLM you can end up with two layers of probabilistic validation.

Have you experimented with any deterministic verification (tests, schema checks, etc.) inside the loop?

This resonates.

Open source gives a lot of people their first real sense of recognition, especially if they didn’t follow traditional paths. But that also makes it really easy to tie your self-worth to something that was never meant to carry that weight.

The “mania looks like productivity” line hits hard. I think a lot of people in tech have seen versions of that, even if they don’t have the same diagnosis.

Appreciate you writing this.

This is funny, but also kind of highlights something real.

A lot of the value people get from LLMs comes from speed and immediacy. Slowing that down probably changes how people think and interact with them quite a bit.

Would be interesting to see if people start using them more deliberately, or just stop using them altogether.

Re:Petition to Node.js TSC: No AI Code in Node.js Core on Wednesday March 18, 2026 @12:11PM (#47427559)
Good point on the reputational component. Tenure builds implicit trust because it signals that someone understands the second-order effects of a change, not just the immediate behavior. An LLM doesn't accumulate that kind of context across contributions. So even if the code itself is correct, the review dynamic shifts because reviewers can't rely on the same assumptions about intent and depth of understanding. That's a real cost that a better test suite alone doesn't solve.
Re:Why AI agents can reduce productivity on Wednesday March 18, 2026 @12:10PM (#47427549)
That's the key tension. If the user already knows the API calls, the agent feels like overhead. The value only clicks when the agent handles the boring parts reliably enough that the user stops thinking about them entirely. Not "it does what I could do" but "it already did it before I had to care." Your direction of running the process and keeping the user informed sounds right. The less the user has to supervise, the more the tool justifies itself.
Re:Why AI agents can reduce productivity on Wednesday March 18, 2026 @11:33AM (#47427058)
This matches what we've seen too. The adoption problem is almost always bigger than the capability problem.

One pattern that helped in our case: instead of asking users to interact with the agent, let the agent interact with verified, pre-tested capabilities on its own and only surface results. The moment you remove "pick the right tool, hope it works, debug when it doesn't" from the human's plate, the attention cost drops dramatically.

The irony is that most agent tooling today actually increases the surface area for failure. Tools that don't install, wrong schemas, silent errors. Each one pulls a human back into the loop. Reliable infrastructure is the prerequisite for the invisible AI you describe in the article.

Re:Petition to Node.js TSC: No AI Code in Node.js Core on Wednesday March 18, 2026 @11:29AM (#47427009)
The core concern here is trust and verification, not really whether a human or LLM typed the characters. Hand-written code can have bugs too. The difference is that hand-written Node.js core has years of battle-testing behind it.

The real risk with LLM-generated code is that it looks plausible but hasn't gone through the same level of scrutiny. It passes a quick review because it reads well, but edge cases get missed.

I think the better question is: what verification pipeline do you put around any contribution, regardless of origin? If the answer is "the same review process we've always had" then the problem isn't AI, it's whether that process is rigorous enough for the stakes involved.